def __init__(self, blueman):
super(ManagerDeviceMenu, self).__init__()
self.set_name("ManagerDeviceMenu")
self.Blueman = blueman
self.SelectedDevice = None
self.is_popup = False
self._device_property_changed_signal = self.Blueman.List.connect(
"device-property-changed", self.on_device_property_changed)
self._selection_done_signal = None
ManagerDeviceMenu.__instances__.append(self)
self._any_network = AnyNetwork()
self._any_network.connect_signal('property-changed',
self._on_service_property_changed)
self._any_device = AnyDevice()
self._any_device.connect_signal('property-changed',
self._on_service_property_changed)
try:
self._appl = AppletService()
except Exception:
logging.error("** Failed to connect to applet", exc_info=True)
self._appl = None
self.Generate()
def setup_transfer(self):
a = AppletService()
status = a.TransferStatus("opp")
if status == -1:
self.widget.props.sensitive = False
self.widget.props.tooltip_text = _("obex-data-server not available")
self.TransConf = Config("transfer")
self.TransConf.connect("property-changed", self.on_property_changed)
opp_enabled = self.Builder.get_object("opp_enabled")
ftp_enabled = self.Builder.get_object("ftp_enabled")
ftp_allow_write = self.Builder.get_object("ftp_allow_write")
opp_accept = self.Builder.get_object("opp_accept")
shared_path = self.Builder.get_object("shared_path")
obex_cmd = self.Builder.get_object("e_obex_cmd")
opp_enabled.props.active = self.TransConf.props.opp_enabled
ftp_enabled.props.active = self.TransConf.props.ftp_enabled
ftp_allow_write.props.active = self.TransConf.props.ftp_allow_write
opp_accept.props.active = self.TransConf.props.opp_accept
if self.TransConf.props.browse_command == None:
self.TransConf.props.browse_command = DEF_BROWSE_COMMAND
obex_cmd.props.text = self.TransConf.props.browse_command
if self.TransConf.props.shared_path != None:
shared_path.set_current_folder(self.TransConf.props.shared_path)
obex_cmd.connect("changed", lambda x: setattr(self.TransConf.props, "browse_command", x.props.text))
opp_enabled.connect("toggled", lambda x: setattr(self.TransConf.props, "opp_enabled", x.props.active))
ftp_enabled.connect("toggled", lambda x: setattr(self.TransConf.props, "ftp_enabled", x.props.active))
ftp_allow_write.connect("toggled", lambda x: setattr(self.TransConf.props, "ftp_allow_write", x.props.active))
opp_accept.connect("toggled", lambda x: setattr(self.TransConf.props, "opp_accept", x.props.active))
shared_path.connect("current-folder-changed", lambda x: setattr(self.TransConf.props, "shared_path", x.get_filename()))
def on_disconnect(self, item, service, port=0):
try:
appl = AppletService()
except:
dprint("** Failed to connect to applet")
return
appl.disconnect_service(service.device.get_object_path(), service.uuid, port)
self.Generate()
def on_dbus_name_appeared(_connection, name, owner):
logging.info("%s %s" % (name, owner))
setup_icon_path()
try:
self.Applet = AppletService()
except:
print("Blueman applet needs to be running")
exit()
try:
if not self.Applet.GetBluetoothStatus():
bt_status_changed(False)
except:
pass
self._applet_sig = self.Applet.connect('g-signal',
on_applet_signal)
self.connect("delete-event", on_window_delete)
self.props.icon_name = "blueman"
w, h, x, y = self.Config["window-properties"]
if w and h: self.resize(w, h)
if x and y: self.move(x, y)
sw = self.Builder.get_object("scrollview")
# Disable overlay scrolling
if Gtk.get_minor_version() >= 16:
sw.props.overlay_scrolling = False
self.List = ManagerDeviceList(adapter=self.Config["last-adapter"],
inst=self)
self.List.show()
sw.add(self.List)
self.Toolbar = ManagerToolbar(self)
self.Menu = ManagerMenu(self)
self.Stats = ManagerStats(self)
if self.List.IsValidAdapter():
self.List.DisplayKnownDevices(autoselect=True)
self.List.connect("adapter-changed", self.on_adapter_changed)
toolbar = self.Builder.get_object("toolbar")
statusbar = self.Builder.get_object("statusbar")
self.Config.bind_to_widget("show-toolbar", toolbar, "visible")
self.Config.bind_to_widget("show-statusbar", statusbar, "visible")
self.show()
def __init__(self, blueman):
super(ManagerDeviceMenu, self).__init__()
self.set_name("ManagerDeviceMenu")
self.Blueman = blueman
self.SelectedDevice = None
self.is_popup = False
self._device_property_changed_signal = self.Blueman.List.connect("device-property-changed",
self.on_device_property_changed)
self._selection_done_signal = None
ManagerDeviceMenu.__instances__.append(self)
self._any_network = AnyNetwork()
self._any_network.connect_signal('property-changed', self._on_service_property_changed)
self._any_device = AnyDevice()
self._any_device.connect_signal('property-changed', self._on_service_property_changed)
try:
self._appl = AppletService()
except Exception:
logging.error("** Failed to connect to applet", exc_info=True)
self._appl = None
self.Generate()
def on_connect(self, _item, service):
device = service.device
def success(*args2):
dprint("success", args2)
prog.message(_("Success!"))
if isinstance(service, SerialPort
) and SERIAL_PORT_SVCLASS_ID == uuid128_to_uuid16(
service.uuid):
MessageArea.show_message(
_("Serial port connected to %s") % args2[0],
"dialog-information")
else:
MessageArea.close()
self.unset_op(device)
def fail(*args):
prog.message(_("Failed"))
self.unset_op(device)
dprint("fail", args)
MessageArea.show_message(
_("Connection Failed: ") + e_(str(args[0])))
self.set_op(device, _("Connecting..."))
prog = ManagerProgressbar(self.Blueman, False)
try:
appl = AppletService()
except:
dprint("** Failed to connect to applet")
fail()
return
try:
appl.SetTimeHint(Gtk.get_current_event_time())
except:
pass
appl.connect_service(device.get_object_path(),
service.uuid,
reply_handler=success,
error_handler=fail,
timeout=200)
prog.start()
def on_load(self, container):
self.Builder = Gtk.Builder()
self.Builder.set_translation_domain("blueman")
self.Builder.add_from_file(UI_PATH + "/services-transfer.ui")
self.widget = self.Builder.get_object("transfer")
self.ignored_keys = []
container.pack_start(self.widget, True, True, 0)
a = AppletService()
if "TransferService" in a.QueryPlugins():
self._setup_transfer()
else:
self.widget.props.sensitive = False
self.widget.props.tooltip_text = _("Applet's transfer service plugin is disabled")
return True
def on_connect(self, _item, service):
device = service.device
def success(obj, result, _user_data):
dprint("success")
prog.message(_("Success!"))
if isinstance(service, SerialPort) and SERIAL_PORT_SVCLASS_ID == uuid128_to_uuid16(service.uuid):
MessageArea.show_message(_("Serial port connected to %s") % result, "dialog-information")
else:
MessageArea.close()
self.unset_op(device)
def fail(obj, result, _user_data):
prog.message(_("Failed"))
self.unset_op(device)
dprint("fail", result)
MessageArea.show_message(_("Connection Failed: ") + e_(str(result.message)))
self.set_op(device, _("Connecting..."))
prog = ManagerProgressbar(self.Blueman, False)
try:
appl = AppletService()
except:
dprint("** Failed to connect to applet")
fail()
return
try:
appl.SetTimeHint(str('(u)'), Gtk.get_current_event_time())
except:
pass
appl.connect_service(str('(ss)'), device.get_object_path(), service.uuid,
result_handler=success, error_handler=fail,
timeout=GLib.MAXINT)
prog.start()
def check_bluetooth_status(message, exitfunc, *args, **kwargs):
try:
applet = AppletService()
except:
print("Blueman applet needs to be running")
exitfunc()
if "PowerManager" in applet.QueryPlugins():
if not applet.GetBluetoothStatus():
d = Gtk.MessageDialog(None, type=Gtk.MessageType.ERROR)
d.props.icon_name = "blueman"
d.props.text = _("Bluetooth Turned Off")
d.props.secondary_text = message
d.add_button("Exit", Gtk.ResponseType.NO)
d.add_button(_("Enable Bluetooth"), Gtk.ResponseType.YES)
resp = d.run()
d.destroy()
if resp != Gtk.ResponseType.YES:
exitfunc()
else:
applet.SetBluetoothStatus('(b)', True, **kwargs)
if not applet.GetBluetoothStatus():
print('Failed to enable bluetooth')
exitfunc()
def on_connect(self, _item, service):
device = service.device
def success(*args2):
dprint("success", " ".join(args2))
prog.message(_("Success!"))
if isinstance(service, SerialPort) and SERIAL_PORT_SVCLASS_ID == uuid128_to_uuid16(service.uuid):
MessageArea.show_message(_("Serial port connected to %s") % args2[0], "dialog-information")
else:
MessageArea.close()
self.unset_op(device)
def fail(*args):
prog.message(_("Failed"))
self.unset_op(device)
dprint("fail", args)
MessageArea.show_message(_("Connection Failed: ") + e_(str(args[0])))
self.set_op(device, _("Connecting..."))
prog = ManagerProgressbar(self.Blueman, False)
try:
appl = AppletService()
except:
dprint("** Failed to connect to applet")
fail()
return
try:
appl.SetTimeHint(Gtk.get_current_event_time())
except:
pass
appl.connect_service(device.get_object_path(), service.uuid,
reply_handler=success, error_handler=fail,
timeout=200)
prog.start()
def check_bluetooth_status(message, exitfunc, *args, **kwargs):
try:
applet = AppletService()
except:
print "Blueman applet needs to be running"
exitfunc()
if "PowerManager" in applet.QueryPlugins():
if not applet.GetBluetoothStatus():
d = gtk.MessageDialog(None, type=gtk.MESSAGE_ERROR)
d.props.icon_name = "blueman"
d.props.text = _("Bluetooth Turned Off")
d.props.secondary_text = message
d.add_button(gtk.STOCK_QUIT, gtk.RESPONSE_NO)
d.add_button(_("Enable Bluetooth"), gtk.RESPONSE_YES)
resp = d.run()
d.destroy()
if resp != gtk.RESPONSE_YES:
exitfunc()
else:
applet.SetBluetoothStatus(True, *args, **kwargs)
def on_dbus_name_appeared(_connection, name, owner):
logging.info("%s %s" % (name, owner))
setup_icon_path()
try:
self.Applet = AppletService()
except:
print("Blueman applet needs to be running")
exit()
try:
if not self.Applet.GetBluetoothStatus():
bt_status_changed(False)
except:
pass
self._applet_sig = self.Applet.connect('g-signal', on_applet_signal)
self.connect("delete-event", on_window_delete)
self.props.icon_name = "blueman"
w, h, x, y = self.Config["window-properties"]
if w and h: self.resize(w, h)
if x and y: self.move(x, y)
sw = self.Builder.get_object("scrollview")
# Disable overlay scrolling
if Gtk.get_minor_version() >= 16:
sw.props.overlay_scrolling = False
self.List = ManagerDeviceList(adapter=self.Config["last-adapter"], inst=self)
self.List.show()
sw.add(self.List)
self.Toolbar = ManagerToolbar(self)
self.Menu = ManagerMenu(self)
self.Stats = ManagerStats(self)
if self.List.IsValidAdapter():
self.List.DisplayKnownDevices(autoselect=True)
self.List.connect("adapter-changed", self.on_adapter_changed)
toolbar = self.Builder.get_object("toolbar")
statusbar = self.Builder.get_object("statusbar")
self.Config.bind_to_widget("show-toolbar", toolbar, "visible")
self.Config.bind_to_widget("show-statusbar", statusbar, "visible")
self.show()
def on_disconnect(self, item, device, service_id, *args):
svc = device.Services[service_id]
if service_id == "serial":
try:
appl = AppletService()
except:
dprint("** Failed to connect to applet")
else:
appl.RfcommDisconnect(device.GetObjectPath(), args[0])
self.Generate()
else:
try:
appl = AppletService()
except:
dprint("** Failed to connect to applet")
return
appl.ServiceProxy(svc.GetInterfaceName(), svc.GetObjectPath(),
"Disconnect", [])
def on_disconnect(self, item, device, service_id=None, *args):
if service_id == "serial":
try:
appl = AppletService()
except:
dprint("** Failed to connect to applet")
else:
appl.RfcommDisconnect(device.get_object_path(), args[0])
self.Generate()
else:
try:
appl = AppletService()
except:
dprint("** Failed to connect to applet")
return
if service_id:
connection_object = device.Services[service_id]
else:
connection_object = device
appl.ServiceProxy(connection_object.get_interface_name(),
connection_object.get_object_path(),
"Disconnect", [])
class ManagerDeviceMenu(Gtk.Menu):
__ops__ = {}
__instances__ = []
def __init__(self, blueman):
super(ManagerDeviceMenu, self).__init__()
self.set_name("ManagerDeviceMenu")
self.Blueman = blueman
self.SelectedDevice = None
self.is_popup = False
self._device_property_changed_signal = self.Blueman.List.connect("device-property-changed",
self.on_device_property_changed)
self._selection_done_signal = None
ManagerDeviceMenu.__instances__.append(self)
self._any_network = AnyNetwork()
self._any_network.connect_signal('property-changed', self._on_service_property_changed)
self._any_device = AnyDevice()
self._any_device.connect_signal('property-changed', self._on_service_property_changed)
try:
self._appl = AppletService()
except Exception:
logging.error("** Failed to connect to applet", exc_info=True)
self._appl = None
self.Generate()
def __del__(self):
logging.debug("deleting devicemenu")
def popup(self, *args):
self.is_popup = True
if not self._device_property_changed_signal:
self._device_property_changed_signal = self.Blueman.List.connect("device-property-changed",
self.on_device_property_changed)
if not self._selection_done_signal:
def disconnectall(x):
self.disconnect(self._device_property_changed_signal)
self.disconnect(self._selection_done_signal)
self._selection_done_signal = self.connect("selection-done", disconnectall)
self.Generate()
super().popup(*args)
def clear(self):
def each(child, data):
self.remove(child)
child.destroy()
self.foreach(each, None)
def set_op(self, device, message):
ManagerDeviceMenu.__ops__[device.get_object_path()] = message
for inst in ManagerDeviceMenu.__instances__:
logging.info("op: regenerating instance %s" % inst)
if inst.SelectedDevice == self.SelectedDevice and not (inst.is_popup and not inst.props.visible):
inst.Generate()
def get_op(self, device):
try:
return ManagerDeviceMenu.__ops__[device.get_object_path()]
except KeyError:
return None
def unset_op(self, device):
del ManagerDeviceMenu.__ops__[device.get_object_path()]
for inst in ManagerDeviceMenu.__instances__:
logging.info("op: regenerating instance %s" % inst)
if inst.SelectedDevice == self.SelectedDevice and not (inst.is_popup and not inst.props.visible):
inst.Generate()
def _on_service_property_changed(self, _service, key, _value, _path):
if key == "Connected":
self.Generate()
def on_connect(self, _item, service):
device = service.device
def success(obj, result, _user_data):
logging.info("success")
prog.message(_("Success!"))
if isinstance(service, SerialPort) and SERIAL_PORT_SVCLASS_ID == service.short_uuid:
MessageArea.show_message(_("Serial port connected to %s") % result, None, "dialog-information")
else:
MessageArea.close()
self.unset_op(device)
def fail(obj, result, _user_data):
prog.message(_("Failed"))
self.unset_op(device)
logging.warning("fail %s" % result)
msg, tb = e_(result.message)
MessageArea.show_message(_("Connection Failed: ") + msg, tb)
self.set_op(device, _("Connecting..."))
prog = ManagerProgressbar(self.Blueman, False)
if self._appl is None:
fail(None, GLib.Error('Applet DBus Service not available'), None)
return
try:
self._appl.SetTimeHint('(u)', Gtk.get_current_event_time())
except Exception as e:
logging.exception(e)
self._appl.connect_service('(os)', device.get_object_path(), service.uuid,
result_handler=success, error_handler=fail,
timeout=GLib.MAXINT)
prog.start()
def on_disconnect(self, item, service, port=0):
def ok(obj, result, user_date):
logging.info("disconnect success")
self.Generate()
def err(obj, result, user_date):
logging.warning("disconnect failed %s" % result)
msg, tb = e_(result.message)
MessageArea.show_message(_("Disconnection Failed: ") + msg, tb)
self.Generate()
if self._appl is None:
err(None, GLib.Error('Applet DBus Service not available'), None)
return
self._appl.disconnect_service('(osd)', service.device.get_object_path(), service.uuid, port,
result_handler=ok, error_handler=err)
def on_device_property_changed(self, List, device, tree_iter, key_value):
key, value = key_value
# print "menu:", key, value
if List.compare(tree_iter, List.selected()):
if key in ("Connected", "UUIDs", "Trusted", "Paired"):
self.Generate()
def _generic_connect(self, item, device, connect):
def fail(obj, result, user_date):
logging.info("fail", result)
prog.message(_("Failed"))
self.unset_op(device)
msg, tb = e_(result.message)
MessageArea.show_message(_("Connection Failed: ") + msg)
def success(obj, result, user_data):
logging.info("success")
prog.message(_("Success!"))
MessageArea.close()
self.unset_op(device)
if connect:
self.set_op(self.SelectedDevice, _("Connecting..."))
self._appl.connect_service("(os)",
device.get_object_path(),
'00000000-0000-0000-0000-000000000000',
result_handler=success, error_handler=fail,
timeout=GLib.MAXINT)
else:
self.set_op(self.SelectedDevice, _("Disconnecting..."))
self._appl.disconnect_service("(osd)",
device.get_object_path(),
'00000000-0000-0000-0000-000000000000',
0,
result_handler=success, error_handler=fail,
timeout=GLib.MAXINT)
prog = ManagerProgressbar(self.Blueman, False)
prog.start()
def Generate(self):
self.clear()
items = []
if not self.is_popup or self.props.visible:
selected = self.Blueman.List.selected()
if not selected:
return
row = self.Blueman.List.get(selected, "alias", "paired", "connected", "trusted", "objpush", "device")
else:
(x, y) = self.Blueman.List.get_pointer()
path = self.Blueman.List.get_path_at_pos(x, y)
if path is not None:
row = self.Blueman.List.get(path[0], "alias", "paired", "connected", "trusted", "objpush", "device")
else:
return
self.SelectedDevice = row["device"]
op = self.get_op(self.SelectedDevice)
if op is not None:
item = create_menuitem(op, "network-transmit-recieve")
item.props.sensitive = False
item.show()
self.append(item)
return
# Generic (dis)connect
# LE devices do not appear to expose certain properties like uuids until connect to at least once.
# show generic connect for these as we will not show any way to connect otherwise.
device_uuids = self.SelectedDevice['UUIDs']
show_generic_connect = not device_uuids
for uuid in device_uuids:
service_uuid = ServiceUUID(uuid)
if service_uuid.short_uuid in (
AUDIO_SOURCE_SVCLASS_ID, AUDIO_SINK_SVCLASS_ID, HANDSFREE_AGW_SVCLASS_ID, HANDSFREE_SVCLASS_ID,
HEADSET_SVCLASS_ID, HID_SVCLASS_ID, 0x1812
):
show_generic_connect = True
break
elif not service_uuid.reserved:
show_generic_connect = uuid == '03b80e5a-ede8-4b33-a751-6ce34ec4c700'
break
if not row["connected"] and show_generic_connect:
connect_item = create_menuitem(_("_Connect"), "blueman")
connect_item.connect("activate", self._generic_connect, self.SelectedDevice, True)
connect_item.props.tooltip_text = _("Connects auto connect profiles A2DP source, A2DP sink, and HID")
connect_item.show()
self.append(connect_item)
elif show_generic_connect:
connect_item = create_menuitem(_("_Disconnect"), "network-offline")
connect_item.props.tooltip_text = _("Forcefully disconnect the device")
connect_item.connect("activate", self._generic_connect, self.SelectedDevice, False)
connect_item.show()
self.append(connect_item)
rets = self.Blueman.Plugins.Run("on_request_menu_items", self, self.SelectedDevice)
for ret in rets:
if ret:
for (item, pos) in ret:
items.append((pos, item))
logging.debug(row["alias"])
have_disconnectables = False
have_connectables = False
if True in map(lambda x: 100 <= x[0] < 200, items):
have_disconnectables = True
if True in map(lambda x: x[0] < 100, items):
have_connectables = True
if True in map(lambda x: x[0] >= 200, items) and (have_connectables or have_disconnectables):
item = Gtk.SeparatorMenuItem()
item.show()
items.append((199, item))
if have_connectables:
item = Gtk.MenuItem()
label = Gtk.Label()
label.set_markup(_("<b>Connect To:</b>"))
label.props.xalign = 0.0
label.show()
item.add(label)
item.props.sensitive = False
item.show()
items.append((0, item))
if have_disconnectables:
item = Gtk.MenuItem()
label = Gtk.Label()
label.set_markup(_("<b>Disconnect:</b>"))
label.props.xalign = 0.0
label.show()
item.add(label)
item.props.sensitive = False
item.show()
items.append((99, item))
items.sort(key=itemgetter(0))
for priority, item in items:
self.append(item)
if items:
item = Gtk.SeparatorMenuItem()
item.show()
self.append(item)
del items
send_item = create_menuitem(_("Send a _File..."), "edit-copy")
send_item.props.sensitive = False
self.append(send_item)
send_item.show()
if row["objpush"]:
send_item.connect("activate", lambda x: self.Blueman.send(self.SelectedDevice))
send_item.props.sensitive = True
item = Gtk.SeparatorMenuItem()
item.show()
self.append(item)
item = create_menuitem(_("_Pair"), "dialog-password")
item.props.tooltip_text = _("Create pairing with the device")
self.append(item)
item.show()
if not row["paired"]:
item.connect("activate", lambda x: self.Blueman.bond(self.SelectedDevice))
else:
item.props.sensitive = False
if not row["trusted"]:
item = create_menuitem(_("_Trust"), "blueman-trust")
item.connect("activate", lambda x: self.Blueman.toggle_trust(self.SelectedDevice))
self.append(item)
item.show()
else:
item = create_menuitem(_("_Untrust"), "blueman-untrust")
self.append(item)
item.connect("activate", lambda x: self.Blueman.toggle_trust(self.SelectedDevice))
item.show()
item.props.tooltip_text = _("Mark/Unmark this device as trusted")
item = create_menuitem(_("_Setup..."), "document-properties")
self.append(item)
item.connect("activate", lambda x: self.Blueman.setup(self.SelectedDevice))
item.show()
item.props.tooltip_text = _("Run the setup assistant for this device")
def on_rename(_item, device):
def on_response(dialog, response_id):
if response_id == Gtk.ResponseType.ACCEPT:
device.set('Alias', alias_entry.get_text())
elif response_id == 1:
device.set('Alias', '')
dialog.destroy()
builder = Gtk.Builder()
builder.set_translation_domain("blueman")
bind_textdomain_codeset("blueman", "UTF-8")
builder.add_from_file(UI_PATH + "/rename-device.ui")
dialog = builder.get_object("dialog")
dialog.set_transient_for(self.Blueman)
dialog.props.icon_name = "blueman"
alias_entry = builder.get_object("alias_entry")
alias_entry.set_text(device['Alias'])
dialog.connect("response", on_response)
dialog.present()
item = Gtk.MenuItem.new_with_mnemonic("R_ename device...")
item.connect('activate', on_rename, self.SelectedDevice)
self.append(item)
item.show()
item = Gtk.SeparatorMenuItem()
item.show()
self.append(item)
item = create_menuitem(_("_Remove..."), "edit-delete")
item.connect("activate", lambda x: self.Blueman.remove(self.SelectedDevice))
self.append(item)
item.show()
item.props.tooltip_text = _("Remove this device from the known devices list")
class Blueman(Gtk.Window):
def __init__(self):
super(Blueman, self).__init__(title=_("Bluetooth Devices"))
self._applet_sig = None
self.Config = Config("org.blueman.general")
self.Builder = Gtk.Builder()
self.Builder.set_translation_domain("blueman")
bind_textdomain_codeset("blueman", "UTF-8")
self.Builder.add_from_file(UI_PATH + "/manager-main.ui")
grid = self.Builder.get_object("grid")
self.add(grid)
self.set_name("BluemanManager")
self.Plugins = PluginManager(ManagerPlugin, blueman.plugins.manager,
self)
self.Plugins.Load()
area = MessageArea()
grid.attach(area, 0, 3, 1, 1)
# Add margin for resize grip or it will overlap
if self.get_has_resize_grip():
statusbar = self.Builder.get_object("statusbar")
margin_right = statusbar.get_margin_right()
statusbar.set_margin_right(margin_right + 10)
def do_present(time):
if self.props.visible:
self.present_with_time(time)
check_single_instance("blueman-manager", do_present)
def on_window_delete(window, event):
w, h = self.get_size()
x, y = self.get_position()
self.Config["window-properties"] = [w, h, x, y]
Gtk.main_quit()
def bt_status_changed(status):
if not status:
self.hide()
check_bluetooth_status(
_("Bluetooth needs to be turned on for the device manager to function"
), lambda: Gtk.main_quit())
else:
self.show()
def on_applet_signal(_proxy, _sender, signal_name, params):
if signal_name == 'BluetoothStatusChanged':
status = params.unpack()
bt_status_changed(status)
def on_dbus_name_vanished(_connection, name):
logging.info(name)
if self._applet_sig is not None:
self.Applet.disconnect(self._applet_sig)
self._applet_sig = None
self.hide()
d = ErrorDialog(
_("Connection to BlueZ failed"),
_("Bluez daemon is not running, blueman-manager cannot continue.\n"
"This probably means that there were no Bluetooth adapters detected "
"or Bluetooth daemon was not started."),
icon_name="blueman")
d.run()
d.destroy()
try:
exit(1)
except:
Gtk.main_quit()
def on_dbus_name_appeared(_connection, name, owner):
logging.info("%s %s" % (name, owner))
setup_icon_path()
try:
self.Applet = AppletService()
except:
print("Blueman applet needs to be running")
exit()
try:
if not self.Applet.GetBluetoothStatus():
bt_status_changed(False)
except:
pass
self._applet_sig = self.Applet.connect('g-signal',
on_applet_signal)
self.connect("delete-event", on_window_delete)
self.props.icon_name = "blueman"
w, h, x, y = self.Config["window-properties"]
if w and h: self.resize(w, h)
if x and y: self.move(x, y)
sw = self.Builder.get_object("scrollview")
# Disable overlay scrolling
if Gtk.get_minor_version() >= 16:
sw.props.overlay_scrolling = False
self.List = ManagerDeviceList(adapter=self.Config["last-adapter"],
inst=self)
self.List.show()
sw.add(self.List)
self.Toolbar = ManagerToolbar(self)
self.Menu = ManagerMenu(self)
self.Stats = ManagerStats(self)
if self.List.IsValidAdapter():
self.List.DisplayKnownDevices(autoselect=True)
self.List.connect("adapter-changed", self.on_adapter_changed)
toolbar = self.Builder.get_object("toolbar")
statusbar = self.Builder.get_object("statusbar")
self.Config.bind_to_widget("show-toolbar", toolbar, "visible")
self.Config.bind_to_widget("show-statusbar", statusbar, "visible")
self.show()
bluez.Manager.watch_name_owner(on_dbus_name_appeared,
on_dbus_name_vanished)
def on_adapter_changed(self, lst, adapter):
if adapter is not None:
self.List.DisplayKnownDevices(autoselect=True)
def inquiry(self):
def prop_changed(List, adapter, key_value):
key, value = key_value
if key == "Discovering" and not value:
prog.finalize()
self.List.disconnect(s1)
self.List.disconnect(s2)
def on_progress(lst, frac):
if abs(1.0 - frac) <= 0.00001:
if not prog.started():
prog.start()
else:
prog.fraction(frac)
prog = ManagerProgressbar(self, text=_("Searching"))
prog.connect("cancelled", lambda x: self.List.StopDiscovery())
try:
self.List.DiscoverDevices()
except Exception as e:
prog.finalize()
MessageArea.show_message(*e_(e))
s1 = self.List.connect("discovery-progress", on_progress)
s2 = self.List.connect("adapter-property-changed", prop_changed)
def setup(self, device):
command = "blueman-assistant --device=%s" % device['Address']
launch(command, None, False, "blueman", _("Bluetooth Assistant"))
def bond(self, device):
def error_handler(e):
logging.exception(e)
message = 'Pairing failed for:\n%s (%s)' % (device['Alias'],
device['Address'])
Notification('Bluetooth', message, icon_name="blueman").show()
device.pair(error_handler=error_handler)
def adapter_properties(self):
launch("blueman-adapters", None, False, "blueman",
_("Adapter Preferences"))
def toggle_trust(self, device):
device['Trusted'] = not device['Trusted']
def send(self, device, File=None):
adapter = self.List.Adapter
command = "blueman-sendto --source=%s --device=%s" % (
adapter["Address"], device['Address'])
launch(command, None, False, "blueman", _("File Sender"))
def remove(self, device):
self.List.Adapter.remove_device(device)
def disconnect(self, device, **kwargs):
applet = AppletService()
applet.DisconnectDevice('(s)', device.get_object_path(), **kwargs)
def on_apply(self):
if self.on_query_apply_state() == True:
try:
a = AppletService()
except:
dprint("failed to connect to applet")
else:
c = self.get_options()
if "opp_enabled" in c:
if not self.TransConf.props.opp_enabled:
a.TransferControl("opp", "destroy")
if "ftp_enabled" in c:
if not self.TransConf.props.ftp_enabled:
a.TransferControl("ftp", "destroy")
if "opp_accept" in c or "shared_path" in c or "opp_enabled" in c:
if self.TransConf.props.opp_enabled:
state = a.TransferStatus("opp")
if state == 0: #destroyed
a.TransferControl("opp", "create")
elif state == 2: #running
a.TransferControl("opp", "stop")
a.TransferControl("opp", "start")
elif state == 1:
a.TransferControl("opp", "start")
if "ftp_allow_write" in c or "shared_path" in c or "ftp_enabled" in c:
if self.TransConf.props.ftp_enabled:
state = a.TransferStatus("ftp")
if state == 0: #destroyed
a.TransferControl("ftp", "create")
elif state == 2: #running
a.TransferControl("ftp", "stop")
a.TransferControl("ftp", "start")
elif state == 1:
a.TransferControl("ftp", "start")
self.clear_options()
dprint("transfer apply")
def Generate(self):
self.clear()
appl = AppletService()
items = []
if not self.is_popup or self.props.visible:
device = self.Blueman.List.get(self.Blueman.List.selected(),
"device")["device"]
else:
(x, y) = self.Blueman.List.get_pointer()
path = self.Blueman.List.get_path_at_pos(x, y)
if path != None:
device = self.Blueman.List.get(path[0][0], "device")["device"]
else:
return
if not device.Valid:
return
self.SelectedDevice = device
op = self.get_op(device)
if op != None:
item = create_menuitem(op, get_icon("gtk-connect", 16))
item.props.sensitive = False
item.show()
self.append(item)
return
rets = self.Blueman.Plugins.Run("on_request_menu_items", self, device)
for ret in rets:
if ret:
for (item, pos) in ret:
items.append((pos, item))
if device.Fake:
item = create_menuitem(_("_Add Device"), get_icon("gtk-add", 16))
self.Signals.Handle("gobject", item, "activate",
lambda x: self.Blueman.add_device(device))
item.show()
self.append(item)
item.props.tooltip_text = _(
"Add this device to known devices list")
item = create_menuitem(_("_Setup..."),
get_icon("gtk-properties", 16))
self.append(item)
self.Signals.Handle("gobject", item, "activate",
lambda x: self.Blueman.setup(device))
item.show()
item.props.tooltip_text = _(
"Run the setup assistant for this device")
item = create_menuitem(_("_Pair"),
get_icon("gtk-dialog-authentication", 16))
self.Signals.Handle("gobject", item, "activate",
lambda x: self.Blueman.bond(device))
self.append(item)
item.show()
item.props.tooltip_text = _("Pair with the device")
item = gtk.SeparatorMenuItem()
item.show()
self.append(item)
send_item = create_menuitem(_("Send a _File..."),
get_icon("gtk-copy", 16))
self.Signals.Handle("gobject", send_item, "activate",
lambda x: self.Blueman.send(device))
send_item.show()
self.append(send_item)
else:
dprint(device.Alias)
item = None
have_disconnectables = False
have_connectables = False
if True in map(lambda x: x[0] >= 100 and x[0] < 200, items):
have_disconnectables = True
if True in map(lambda x: x[0] < 100, items):
have_connectables = True
if True in map(lambda x: x[0] >= 200,
items) and (have_connectables
or have_disconnectables):
item = gtk.SeparatorMenuItem()
item.show()
items.append((199, item))
if have_connectables:
item = gtk.MenuItem()
label = gtk.Label()
label.set_markup(_("<b>Connect To:</b>"))
label.props.xalign = 0.0
label.show()
item.add(label)
item.props.sensitive = False
item.show()
items.append((0, item))
if have_disconnectables:
item = gtk.MenuItem()
label = gtk.Label()
label.set_markup(_("<b>Disconnect:</b>"))
label.props.xalign = 0.0
label.show()
item.add(label)
item.props.sensitive = False
item.show()
items.append((99, item))
items.sort(lambda a, b: cmp(a[0], b[0]))
for priority, item in items:
self.append(item)
if items != []:
item = gtk.SeparatorMenuItem()
item.show()
self.append(item)
del items
send_item = create_menuitem(_("Send a _File..."),
get_icon("gtk-copy", 16))
send_item.props.sensitive = False
self.append(send_item)
send_item.show()
browse_item = create_menuitem(_("_Browse Device..."),
get_icon("gtk-open", 16))
browse_item.props.sensitive = False
self.append(browse_item)
browse_item.show()
uuids = device.UUIDs
for uuid in uuids:
uuid16 = uuid128_to_uuid16(uuid)
if uuid16 == OBEX_OBJPUSH_SVCLASS_ID:
self.Signals.Handle("gobject", send_item, "activate",
lambda x: self.Blueman.send(device))
send_item.props.sensitive = True
if uuid16 == OBEX_FILETRANS_SVCLASS_ID:
self.Signals.Handle("gobject", browse_item, "activate",
lambda x: self.Blueman.browse(device))
browse_item.props.sensitive = True
item = gtk.SeparatorMenuItem()
item.show()
self.append(item)
item = create_menuitem(_("_Pair"),
get_icon("gtk-dialog-authentication", 16))
item.props.tooltip_text = _("Create pairing with the device")
self.append(item)
item.show()
if not device.Paired:
self.Signals.Handle("gobject", item, "activate",
lambda x: self.Blueman.bond(device))
else:
item.props.sensitive = False
if not device.Trusted:
item = create_menuitem(_("_Trust"),
get_icon("blueman-trust", 16))
self.Signals.Handle(
"gobject", item, "activate",
lambda x: self.Blueman.toggle_trust(device))
self.append(item)
item.show()
else:
item = create_menuitem(_("_Untrust"),
get_icon("blueman-untrust", 16))
self.append(item)
self.Signals.Handle(
"gobject", item, "activate",
lambda x: self.Blueman.toggle_trust(device))
item.show()
item.props.tooltip_text = _("Mark/Unmark this device as trusted")
item = create_menuitem(_("_Setup..."),
get_icon("gtk-properties", 16))
self.append(item)
self.Signals.Handle("gobject", item, "activate",
lambda x: self.Blueman.setup(device))
item.show()
item.props.tooltip_text = _(
"Run the setup assistant for this device")
def update_services(item):
def reply():
self.unset_op(device)
prog.message(_("Success!"))
MessageArea.close()
def error(*args):
self.unset_op(device)
prog.message(_("Fail"))
MessageArea.show_message(e_(str(args[0])))
prog = ManagerProgressbar(self.Blueman, False, _("Refreshing"))
prog.start()
self.set_op(device, _("Refreshing Services..."))
appl.RefreshServices(device.GetObjectPath(),
reply_handler=reply,
error_handler=error)
item = create_menuitem(_("Refresh Services"),
get_icon("gtk-refresh", 16))
self.append(item)
self.Signals.Handle(item, "activate", update_services)
item.show()
item = gtk.SeparatorMenuItem()
item.show()
self.append(item)
item = create_menuitem(_("_Remove..."), get_icon("gtk-delete", 16))
self.Signals.Handle(item, "activate",
lambda x: self.Blueman.remove(device))
self.append(item)
item.show()
item.props.tooltip_text = _(
"Remove this device from the known devices list")
item = gtk.SeparatorMenuItem()
item.show()
self.append(item)
item = create_menuitem(_("_Disconnect"),
get_icon("gtk-disconnect", 16))
item.props.tooltip_text = _("Forcefully disconnect the device")
self.append(item)
item.show()
def on_disconnect(item):
def finished(*args):
self.unset_op(device)
self.set_op(device, _("Disconnecting..."))
self.Blueman.disconnect(device,
reply_handler=finished,
error_handler=finished)
if device.Connected:
self.Signals.Handle(item, "activate", on_disconnect)
else:
item.props.sensitive = False
class Blueman(Gtk.Window):
def __init__(self):
super(Blueman, self).__init__(title=_("Bluetooth Devices"))
self._applet_sig = None
self.Config = Config("org.blueman.general")
self.Builder = Gtk.Builder()
self.Builder.set_translation_domain("blueman")
bind_textdomain_codeset("blueman", "UTF-8")
self.Builder.add_from_file(UI_PATH + "/manager-main.ui")
grid = self.Builder.get_object("grid")
self.add(grid)
self.set_name("BluemanManager")
self.Plugins = PluginManager(ManagerPlugin, blueman.plugins.manager, self)
self.Plugins.Load()
area = MessageArea()
grid.attach(area, 0, 3, 1, 1)
# Add margin for resize grip or it will overlap
if self.get_has_resize_grip():
statusbar = self.Builder.get_object("statusbar")
margin_right = statusbar.get_margin_right()
statusbar.set_margin_right(margin_right + 10)
def do_present(time):
if self.props.visible:
self.present_with_time(time)
check_single_instance("blueman-manager", do_present)
def on_window_delete(window, event):
w, h = self.get_size()
x, y = self.get_position()
self.Config["window-properties"] = [w, h, x, y]
Gtk.main_quit()
def bt_status_changed(status):
if not status:
self.hide()
check_bluetooth_status(_("Bluetooth needs to be turned on for the device manager to function"),
lambda: Gtk.main_quit())
else:
self.show()
def on_applet_signal(_proxy, _sender, signal_name, params):
if signal_name == 'BluetoothStatusChanged':
status = params.unpack()
bt_status_changed(status)
def on_dbus_name_vanished(_connection, name):
logging.info(name)
if self._applet_sig is not None:
self.Applet.disconnect(self._applet_sig)
self._applet_sig = None
self.hide()
d = ErrorDialog(
_("Connection to BlueZ failed"),
_("Bluez daemon is not running, blueman-manager cannot continue.\n"
"This probably means that there were no Bluetooth adapters detected "
"or Bluetooth daemon was not started."),
icon_name="blueman")
d.run()
d.destroy()
try:
exit(1)
except:
Gtk.main_quit()
def on_dbus_name_appeared(_connection, name, owner):
logging.info("%s %s" % (name, owner))
setup_icon_path()
try:
self.Applet = AppletService()
except:
print("Blueman applet needs to be running")
exit()
try:
if not self.Applet.GetBluetoothStatus():
bt_status_changed(False)
except:
pass
self._applet_sig = self.Applet.connect('g-signal', on_applet_signal)
self.connect("delete-event", on_window_delete)
self.props.icon_name = "blueman"
w, h, x, y = self.Config["window-properties"]
if w and h: self.resize(w, h)
if x and y: self.move(x, y)
sw = self.Builder.get_object("scrollview")
# Disable overlay scrolling
if Gtk.get_minor_version() >= 16:
sw.props.overlay_scrolling = False
self.List = ManagerDeviceList(adapter=self.Config["last-adapter"], inst=self)
self.List.show()
sw.add(self.List)
self.Toolbar = ManagerToolbar(self)
self.Menu = ManagerMenu(self)
self.Stats = ManagerStats(self)
if self.List.IsValidAdapter():
self.List.DisplayKnownDevices(autoselect=True)
self.List.connect("adapter-changed", self.on_adapter_changed)
toolbar = self.Builder.get_object("toolbar")
statusbar = self.Builder.get_object("statusbar")
self.Config.bind_to_widget("show-toolbar", toolbar, "visible")
self.Config.bind_to_widget("show-statusbar", statusbar, "visible")
self.show()
bluez.Manager.watch_name_owner(on_dbus_name_appeared, on_dbus_name_vanished)
def on_adapter_changed(self, lst, adapter):
if adapter is not None:
self.List.DisplayKnownDevices(autoselect=True)
def inquiry(self):
def prop_changed(List, adapter, key_value):
key, value = key_value
if key == "Discovering" and not value:
prog.finalize()
self.List.disconnect(s1)
self.List.disconnect(s2)
def on_progress(lst, frac):
if abs(1.0 - frac) <= 0.00001:
if not prog.started():
prog.start()
else:
prog.fraction(frac)
prog = ManagerProgressbar(self, text=_("Searching"))
prog.connect("cancelled", lambda x: self.List.StopDiscovery())
try:
self.List.DiscoverDevices()
except Exception as e:
prog.finalize()
MessageArea.show_message(*e_(e))
s1 = self.List.connect("discovery-progress", on_progress)
s2 = self.List.connect("adapter-property-changed", prop_changed)
def setup(self, device):
command = "blueman-assistant --device=%s" % device['Address']
launch(command, None, False, "blueman", _("Bluetooth Assistant"))
def bond(self, device):
def error_handler(e):
logging.exception(e)
message = 'Pairing failed for:\n%s (%s)' % (device['Alias'], device['Address'])
Notification('Bluetooth', message, icon_name="blueman").show()
device.pair(error_handler=error_handler)
def adapter_properties(self):
launch("blueman-adapters", None, False, "blueman", _("Adapter Preferences"))
def toggle_trust(self, device):
device['Trusted'] = not device['Trusted']
def send(self, device, File=None):
adapter = self.List.Adapter
command = "blueman-sendto --source=%s --device=%s" % (adapter["Address"], device['Address'])
launch(command, None, False, "blueman", _("File Sender"))
def remove(self, device):
self.List.Adapter.remove_device(device)
def disconnect(self, device, **kwargs):
applet = AppletService()
applet.DisconnectDevice('(s)', device.get_object_path(), **kwargs)
def Generate(self):
self.clear()
appl = AppletService()
items = []
if not self.is_popup or self.props.visible:
selected = self.Blueman.List.selected()
if not selected:
return
device = self.Blueman.List.get(selected, "device")["device"]
else:
(x, y) = self.Blueman.List.get_pointer()
path = self.Blueman.List.get_path_at_pos(x, y)
if path != None:
device = self.Blueman.List.get(path[0], "device")["device"]
else:
return
if not device.Valid:
return
self.SelectedDevice = device
op = self.get_op(device)
if op != None:
item = create_menuitem(op, get_icon("network-transmit-recieve",
16))
item.props.sensitive = False
item.show()
self.append(item)
return
rets = self.Blueman.Plugins.Run("on_request_menu_items", self, device)
for ret in rets:
if ret:
for (item, pos) in ret:
items.append((pos, item))
if device.Fake:
item = create_menuitem(_("_Add Device"), get_icon("list-add", 16))
self.Signals.Handle("gobject", item, "activate",
lambda x: self.Blueman.add_device(device))
item.show()
self.append(item)
item.props.tooltip_text = _(
"Add this device to known devices list")
item = create_menuitem(_("_Setup..."),
get_icon("document-properties", 16))
self.append(item)
self.Signals.Handle("gobject", item, "activate",
lambda x: self.Blueman.setup(device))
item.show()
item.props.tooltip_text = _(
"Run the setup assistant for this device")
item = create_menuitem(_("_Pair"), get_icon("dialog-password", 16))
self.Signals.Handle("gobject", item, "activate",
lambda x: self.Blueman.bond(device))
self.append(item)
item.show()
item.props.tooltip_text = _("Pair with the device")
item = Gtk.SeparatorMenuItem()
item.show()
self.append(item)
send_item = create_menuitem(_("Send a _File..."),
get_icon("edit-copy", 16))
self.Signals.Handle("gobject", send_item, "activate",
lambda x: self.Blueman.send(device))
send_item.show()
self.append(send_item)
else:
dprint(device.Alias)
item = None
have_disconnectables = False
have_connectables = False
if True in map(lambda x: x[0] >= 100 and x[0] < 200, items):
have_disconnectables = True
if True in map(lambda x: x[0] < 100, items):
have_connectables = True
if True in map(lambda x: x[0] >= 200,
items) and (have_connectables
or have_disconnectables):
item = Gtk.SeparatorMenuItem()
item.show()
items.append((199, item))
if have_connectables:
item = Gtk.MenuItem()
label = Gtk.Label()
label.set_markup(_("<b>Connect To:</b>"))
label.props.xalign = 0.0
label.show()
item.add(label)
item.props.sensitive = False
item.show()
items.append((0, item))
if have_disconnectables:
item = Gtk.MenuItem()
label = Gtk.Label()
label.set_markup(_("<b>Disconnect:</b>"))
label.props.xalign = 0.0
label.show()
item.add(label)
item.props.sensitive = False
item.show()
items.append((99, item))
items.sort(key=itemgetter(0))
for priority, item in items:
self.append(item)
if items != []:
item = Gtk.SeparatorMenuItem()
item.show()
self.append(item)
del items
send_item = create_menuitem(_("Send a _File..."),
get_icon("edit-copy", 16))
send_item.props.sensitive = False
self.append(send_item)
send_item.show()
browse_item = create_menuitem(_("_Browse Device..."),
get_icon("document-open", 16))
browse_item.props.sensitive = False
self.append(browse_item)
browse_item.show()
uuids = device.UUIDs
for uuid in uuids:
uuid16 = uuid128_to_uuid16(uuid)
if uuid16 == OBEX_OBJPUSH_SVCLASS_ID:
self.Signals.Handle("gobject", send_item, "activate",
lambda x: self.Blueman.send(device))
send_item.props.sensitive = True
if uuid16 == OBEX_FILETRANS_SVCLASS_ID:
self.Signals.Handle("gobject", browse_item, "activate",
lambda x: self.Blueman.browse(device))
browse_item.props.sensitive = True
item = Gtk.SeparatorMenuItem()
item.show()
self.append(item)
item = create_menuitem(_("_Pair"), get_icon("dialog-password", 16))
item.props.tooltip_text = _("Create pairing with the device")
self.append(item)
item.show()
if not device.Paired:
self.Signals.Handle("gobject", item, "activate",
lambda x: self.Blueman.bond(device))
else:
item.props.sensitive = False
if not device.Trusted:
item = create_menuitem(_("_Trust"),
get_icon("blueman-trust", 16))
self.Signals.Handle(
"gobject", item, "activate",
lambda x: self.Blueman.toggle_trust(device))
self.append(item)
item.show()
else:
item = create_menuitem(_("_Untrust"),
get_icon("blueman-untrust", 16))
self.append(item)
self.Signals.Handle(
"gobject", item, "activate",
lambda x: self.Blueman.toggle_trust(device))
item.show()
item.props.tooltip_text = _("Mark/Unmark this device as trusted")
item = create_menuitem(_("_Setup..."),
get_icon("document-properties", 16))
self.append(item)
self.Signals.Handle("gobject", item, "activate",
lambda x: self.Blueman.setup(device))
item.show()
item.props.tooltip_text = _(
"Run the setup assistant for this device")
def on_rename(_item, device):
def on_response(dialog, response_id):
if response_id == Gtk.ResponseType.ACCEPT:
device.set('Alias', alias_entry.get_text())
elif response_id == 1:
device.set('Alias', '')
dialog.destroy()
builder = Gtk.Builder()
builder.set_translation_domain("blueman")
builder.add_from_file(UI_PATH + "/rename-device.ui")
dialog = builder.get_object("dialog")
dialog.set_transient_for(self.Blueman.window)
dialog.props.icon_name = "blueman"
alias_entry = builder.get_object("alias_entry")
alias_entry.set_text(device.Alias)
dialog.connect("response", on_response)
dialog.present()
item = Gtk.MenuItem.new_with_label("Rename device...")
self.Signals.Handle(item, 'activate', on_rename, device)
self.append(item)
item.show()
item = Gtk.SeparatorMenuItem()
item.show()
self.append(item)
item = create_menuitem(_("_Remove..."),
get_icon("edit-delete", 16))
self.Signals.Handle(item, "activate",
lambda x: self.Blueman.remove(device))
self.append(item)
item.show()
item.props.tooltip_text = _(
"Remove this device from the known devices list")
item = Gtk.SeparatorMenuItem()
item.show()
self.append(item)
item = create_menuitem(_("_Disconnect"),
get_icon("network-offline", 16))
item.props.tooltip_text = _("Forcefully disconnect the device")
self.append(item)
item.show()
def on_disconnect(item):
def finished(*args):
self.unset_op(device)
self.set_op(device, _("Disconnecting..."))
self.Blueman.disconnect(device,
reply_handler=finished,
error_handler=finished)
if device.Connected:
self.Signals.Handle(item, "activate", on_disconnect)
else:
item.props.sensitive = False
def disconnect(self, device, **kwargs):
applet = AppletService()
applet.DisconnectDevice('(s)', device.get_object_path(), **kwargs)
def setup_network(self):
self.Config = Config("org.blueman.network")
nap_enable = self.Builder.get_object("nap-enable")
r_dnsmasq = self.Builder.get_object("r_dnsmasq")
r_dhcpd = self.Builder.get_object("r_dhcpd")
r_udhcpd = self.Builder.get_object("r_udhcpd")
net_ip = self.Builder.get_object("net_ip")
rb_nm = self.Builder.get_object("rb_nm")
rb_blueman = self.Builder.get_object("rb_blueman")
rb_dun_nm = self.Builder.get_object("rb_dun_nm")
rb_dun_blueman = self.Builder.get_object("rb_dun_blueman")
nap_frame = self.Builder.get_object("nap_frame")
warning = self.Builder.get_object("warning")
if not self.Config["nap-enable"]:
nap_frame.props.sensitive = False
nc = NetConf.get_default()
if nc.ip4_address is not None:
net_ip.props.text = inet_ntoa(nc.ip4_address)
nap_enable.props.active = True
else:
net_ip.props.text = "10.%d.%d.1" % (randint(0, 255), randint(
0, 255))
if nc.get_dhcp_handler() is None:
nap_frame.props.sensitive = False
nap_enable.props.active = False
r_dnsmasq.props.active = True
self.Config["nap-enable"] = False
have_dhcpd = have("dhcpd3") or have("dhcpd")
have_dnsmasq = have("dnsmasq")
have_udhcpd = have("udhcpd")
if nc.get_dhcp_handler() == DnsMasqHandler and have_dnsmasq:
r_dnsmasq.props.active = True
elif nc.get_dhcp_handler() == DhcpdHandler and have_dhcpd:
r_dhcpd.props.active = True
elif nc.get_dhcp_handler() == UdhcpdHandler and have_udhcpd:
r_udhcpd.props.active = True
else:
r_dnsmasq.props.active = True
if not have_dnsmasq and not have_dhcpd and not have_udhcpd:
nap_frame.props.sensitive = False
warning.props.visible = True
warning.props.sensitive = True
nap_enable.props.sensitive = False
self.Config["nap-enable"] = False
if not have_dnsmasq:
r_dnsmasq.props.sensitive = False
r_dnsmasq.props.active = False
if not have_dhcpd:
r_dhcpd.props.sensitive = False
r_dhcpd.props.active = False
if not have_udhcpd:
r_udhcpd.props.sensitive = False
r_udhcpd.props.active = False
r_dnsmasq.connect("toggled",
lambda x: self.option_changed_notify("dnsmasq"))
r_dhcpd.connect("toggled",
lambda x: self.option_changed_notify("dhcpd"))
r_udhcpd.connect("toggled",
lambda x: self.option_changed_notify("udhcpd"))
net_ip.connect("changed",
lambda x: self.option_changed_notify("ip", False))
nap_enable.connect("toggled",
lambda x: self.option_changed_notify("nap_enable"))
self.Config.bind_to_widget("nap-enable", nap_enable, "active",
Gio.SettingsBindFlags.GET)
nap_enable.bind_property("active", nap_frame, "sensitive", 0)
applet = AppletService()
avail_plugins = applet.QueryAvailablePlugins()
active_plugins = applet.QueryPlugins()
def dun_support_toggled(rb, x):
if rb.props.active and x == "nm":
applet.SetPluginConfig('(sb)', "PPPSupport", False)
applet.SetPluginConfig('(sb)', "NMDUNSupport", True)
elif rb.props.active and x == "blueman":
applet.SetPluginConfig('(sb)', "NMDUNSupport", False)
applet.SetPluginConfig('(sb)', "PPPSupport", True)
def pan_support_toggled(rb, x):
if rb.props.active and x == "nm":
applet.SetPluginConfig('(sb)', "DhcpClient", False)
applet.SetPluginConfig('(sb)', "NMPANSupport", True)
elif rb.props.active and x == "blueman":
applet.SetPluginConfig('(sb)', "NMPANSupport", False)
applet.SetPluginConfig('(sb)', "DhcpClient", True)
if "PPPSupport" in active_plugins:
rb_dun_blueman.props.active = True
if "NMDUNSupport" in avail_plugins:
rb_dun_nm.props.sensitive = True
else:
rb_dun_nm.props.sensitive = False
rb_dun_nm.props.tooltip_text = _(
"Not currently supported with this setup")
if "DhcpClient" in active_plugins:
rb_blueman.props.active = True
if "NMPANSupport" in avail_plugins:
rb_nm.props.sensitive = True
else:
rb_nm.props.sensitive = False
rb_nm.props.tooltip_text = _(
"Not currently supported with this setup")
if "NMPANSupport" in active_plugins:
rb_nm.props.active = True
if "NMDUNSupport" in active_plugins:
rb_dun_nm.props.active = True
rb_nm.connect("toggled", pan_support_toggled, "nm")
rb_blueman.connect("toggled", pan_support_toggled, "blueman")
rb_dun_nm.connect("toggled", dun_support_toggled, "nm")
rb_dun_blueman.connect("toggled", dun_support_toggled, "blueman")
def Generate(self):
self.clear()
appl = AppletService()
items = []
if not self.is_popup or self.props.visible:
selected = self.Blueman.List.selected()
if not selected:
return
row = self.Blueman.List.get(selected, "alias", "bonded",
"connected", "trusted", "objpush",
"device")
else:
(x, y) = self.Blueman.List.get_pointer()
path = self.Blueman.List.get_path_at_pos(x, y)
if path is not None:
row = self.Blueman.List.get(path[0], "alias", "bonded",
"connected", "trusted", "objpush",
"device")
else:
return
self.SelectedDevice = row["device"]
op = self.get_op(self.SelectedDevice)
if op is not None:
item = create_menuitem(op, get_icon("network-transmit-recieve",
16))
item.props.sensitive = False
item.show()
self.append(item)
return
rets = self.Blueman.Plugins.Run("on_request_menu_items", self,
self.SelectedDevice)
for ret in rets:
if ret:
for (item, pos) in ret:
items.append((pos, item))
dprint(row["alias"])
have_disconnectables = False
have_connectables = False
if True in map(lambda x: 100 <= x[0] < 200, items):
have_disconnectables = True
if True in map(lambda x: x[0] < 100, items):
have_connectables = True
if True in map(lambda x: x[0] >= 200,
items) and (have_connectables or have_disconnectables):
item = Gtk.SeparatorMenuItem()
item.show()
items.append((199, item))
if have_connectables:
item = Gtk.MenuItem()
label = Gtk.Label()
label.set_markup(_("<b>Connect To:</b>"))
label.props.xalign = 0.0
label.show()
item.add(label)
item.props.sensitive = False
item.show()
items.append((0, item))
if have_disconnectables:
item = Gtk.MenuItem()
label = Gtk.Label()
label.set_markup(_("<b>Disconnect:</b>"))
label.props.xalign = 0.0
label.show()
item.add(label)
item.props.sensitive = False
item.show()
items.append((99, item))
items.sort(key=itemgetter(0))
for priority, item in items:
self.append(item)
if items:
item = Gtk.SeparatorMenuItem()
item.show()
self.append(item)
del items
send_item = create_menuitem(_("Send a _File..."),
get_icon("edit-copy", 16))
send_item.props.sensitive = False
self.append(send_item)
send_item.show()
if row["objpush"]:
send_item.connect("activate",
lambda x: self.Blueman.send(self.SelectedDevice))
send_item.props.sensitive = True
item = Gtk.SeparatorMenuItem()
item.show()
self.append(item)
item = create_menuitem(_("_Pair"), get_icon("dialog-password", 16))
item.props.tooltip_text = _("Create pairing with the device")
self.append(item)
item.show()
if not row["bonded"]:
item.connect("activate",
lambda x: self.Blueman.bond(self.SelectedDevice))
else:
item.props.sensitive = False
if not row["trusted"]:
item = create_menuitem(_("_Trust"), get_icon("blueman-trust", 16))
item.connect(
"activate",
lambda x: self.Blueman.toggle_trust(self.SelectedDevice))
self.append(item)
item.show()
else:
item = create_menuitem(_("_Untrust"),
get_icon("blueman-untrust", 16))
self.append(item)
item.connect(
"activate",
lambda x: self.Blueman.toggle_trust(self.SelectedDevice))
item.show()
item.props.tooltip_text = _("Mark/Unmark this device as trusted")
item = create_menuitem(_("_Setup..."),
get_icon("document-properties", 16))
self.append(item)
item.connect("activate",
lambda x: self.Blueman.setup(self.SelectedDevice))
item.show()
item.props.tooltip_text = _("Run the setup assistant for this device")
def on_rename(_item, device):
def on_response(dialog, response_id):
if response_id == Gtk.ResponseType.ACCEPT:
device.set('Alias', alias_entry.get_text())
elif response_id == 1:
device.set('Alias', '')
dialog.destroy()
builder = Gtk.Builder()
builder.set_translation_domain("blueman")
bind_textdomain_codeset("blueman", "UTF-8")
builder.add_from_file(UI_PATH + "/rename-device.ui")
dialog = builder.get_object("dialog")
dialog.set_transient_for(self.Blueman)
dialog.props.icon_name = "blueman"
alias_entry = builder.get_object("alias_entry")
alias_entry.set_text(device['Alias'])
dialog.connect("response", on_response)
dialog.present()
item = Gtk.MenuItem.new_with_label("Rename device...")
item.connect('activate', on_rename, self.SelectedDevice)
self.append(item)
item.show()
item = Gtk.SeparatorMenuItem()
item.show()
self.append(item)
item = create_menuitem(_("_Remove..."), get_icon("edit-delete", 16))
item.connect("activate",
lambda x: self.Blueman.remove(self.SelectedDevice))
self.append(item)
item.show()
item.props.tooltip_text = _(
"Remove this device from the known devices list")
item = Gtk.SeparatorMenuItem()
item.show()
self.append(item)
item = create_menuitem(_("_Disconnect"),
get_icon("network-offline", 16))
item.props.tooltip_text = _("Forcefully disconnect the device")
self.append(item)
item.show()
def on_disconnect(item):
def finished(*args):
self.unset_op(self.SelectedDevice)
self.set_op(self.SelectedDevice, _("Disconnecting..."))
self.Blueman.disconnect(self.SelectedDevice,
reply_handler=finished,
error_handler=finished)
if row['connected']:
item.connect("activate", on_disconnect)
else:
item.props.sensitive = False
def setup_network(self):
self.Config = Config("org.blueman.network")
gn_enable = self.Builder.get_object("gn-enable")
# latest bluez does not support GN, apparently
gn_enable.props.visible = False
nap_enable = self.Builder.get_object("nap-enable")
r_dnsmasq = self.Builder.get_object("r_dnsmasq")
r_dhcpd = self.Builder.get_object("r_dhcpd")
net_ip = self.Builder.get_object("net_ip")
net_nat = self.Builder.get_object("net_nat")
rb_nm = self.Builder.get_object("rb_nm")
rb_blueman = self.Builder.get_object("rb_blueman")
rb_dun_nm = self.Builder.get_object("rb_dun_nm")
rb_dun_blueman = self.Builder.get_object("rb_dun_blueman")
nap_frame = self.Builder.get_object("nap_frame")
warning = self.Builder.get_object("warning")
rb_blueman.props.active = self.Config["dhcp-client"]
if not self.Config["nap-enable"]:
nap_frame.props.sensitive = False
nc = NetConf.get_default()
if nc.ip4_address != None:
net_ip.props.text = inet_ntoa(nc.ip4_address)
else:
net_ip.props.text = "10.%d.%d.1" % (randint(0, 255), randint(
0, 255))
#if ns["masq"] != 0:
# net_nat.props.active = ns["masq"]
if nc.get_dhcp_handler() == None:
nap_frame.props.sensitive = False
nap_enable.props.active = False
else:
if nc.get_dhcp_handler() == DnsMasqHandler:
r_dnsmasq.props.active = True
else:
r_dhcpd.props.active = True
if not have("dnsmasq") and not have("dhcpd3") and not have("dhcpd"):
nap_frame.props.sensitive = False
warning.props.visible = True
warning.props.sensitive = True
nap_enable.props.sensitive = False
if not have("dnsmasq"):
r_dnsmasq.props.sensitive = False
r_dnsmasq.props.active = False
r_dhcpd.props.active = True
if not have("dhcpd3") and not have("dhcpd"):
r_dhcpd.props.sensitive = False
r_dhcpd.props.active = False
r_dnsmasq.props.active = True
r_dnsmasq.connect("toggled",
lambda x: self.option_changed_notify("dnsmasq"))
net_ip.connect("changed",
lambda x: self.option_changed_notify("ip", False))
self.Config.bind_to_widget("nat", net_nat, "active")
self.Config.bind_to_widget("gn-enable", gn_enable, "active")
self.Config.bind_to_widget("nap-enable", nap_frame, "sensitive")
self.Config.bind_to_widget("nap-enable", nap_enable, "active")
applet = AppletService()
avail_plugins = applet.QueryAvailablePlugins()
active_plugins = applet.QueryPlugins()
def dun_support_toggled(rb, x):
if rb.props.active and x == "nm":
applet.SetPluginConfig("PPPSupport", False)
applet.SetPluginConfig("NMDUNSupport", True)
elif rb.props.active and x == "blueman":
applet.SetPluginConfig("NMDUNSupport", False)
applet.SetPluginConfig("PPPSupport", True)
def pan_support_toggled(rb, x):
if rb.props.active and x == "nm":
applet.SetPluginConfig("DhcpClient", False)
applet.SetPluginConfig("NMPANSupport", True)
elif rb.props.active and x == "blueman":
applet.SetPluginConfig("NMPANSupport", False)
applet.SetPluginConfig("DhcpClient", True)
if "PPPSupport" in active_plugins:
rb_dun_blueman.props.active = True
if "NMDUNSupport" in avail_plugins:
rb_dun_nm.props.sensitive = True
else:
rb_dun_nm.props.sensitive = False
rb_dun_nm.props.tooltip_text = _(
"Not currently supported with this setup")
if "NMPANSupport" in avail_plugins:
rb_nm.props.sensitive = True
else:
rb_nm.props.sensitive = False
rb_nm.props.tooltip_text = _(
"Not currently supported with this setup")
if "NMPANSupport" in active_plugins:
rb_nm.props.active = True
if "NMDUNSupport" in active_plugins:
rb_dun_nm.props.active = True
rb_nm.connect("toggled", pan_support_toggled, "nm")
rb_blueman.connect("toggled", pan_support_toggled, "blueman")
rb_dun_nm.connect("toggled", dun_support_toggled, "nm")
rb_dun_blueman.connect("toggled", dun_support_toggled, "blueman")
from blueman.plugins.ManagerPlugin import ManagerPlugin
from blueman.main.PulseAudioUtils import PulseAudioUtils, EventType
from blueman.main.SignalTracker import SignalTracker
from blueman.gui.manager.ManagerDeviceMenu import ManagerDeviceMenu
from blueman.gui.MessageArea import MessageArea
from blueman.Functions import get_icon, create_menuitem
from blueman.main.AppletService import AppletService
import gtk
a = AppletService()
if not "PulseAudio" in a.QueryPlugins():
raise ImportError("PulseAudio applet plugin not loaded, nothing to do here")
class PulseAudioProfile(ManagerPlugin):
def on_load(self, user_data):
self.devices = {}
self.item = None
self.deferred = []
pa = PulseAudioUtils()
pa.connect("event", self.on_pa_event)
pa.connect("connected", self.on_pa_ready)
def on_pa_ready(self, utils):
dprint("connected")
for dev in self.deferred:
self.regenerate_with_device(dev.Address)
def on_request_menu_items(self, manager_menu, device):
if BlueZInterface.get_interface_version()[0] < 5:
return self.on_request_menu_items_bluez4(manager_menu, device)
items = []
uuids = device.UUIDs
appl = AppletService()
uuids16 = [uuid128_to_uuid16(uuid) for uuid in uuids]
if set(uuids16) & set(self.connectable_uuids):
# FIXME: This should only be done once!
manager_menu.Signals.Handle("bluez", device,
manager_menu.service_property_changed,
"PropertyChanged")
if device.get_properties()['Connected']:
# FIXME: More generic icon
item = create_menuitem(_("_Disconnect"),
get_x_icon("mouse", 16))
manager_menu.Signals.Handle("gobject", item, "activate",
manager_menu.on_disconnect, device)
items.append((item, 100))
else:
# FIXME: More generic icon
item = create_menuitem(_("_Connect"), get_icon("mouse", 16))
manager_menu.Signals.Handle("gobject", item, "activate",
manager_menu.on_connect, device)
items.append((item, 1))
item.show()
for name, service in device.Services.items():
if name == "network":
manager_menu.Signals.Handle(
"bluez", service, manager_menu.service_property_changed,
"PropertyChanged")
sprops = service.get_properties()
if not sprops["Connected"]:
for uuid in uuids:
uuid16 = uuid128_to_uuid16(uuid)
if uuid16 == NAP_SVCLASS_ID or uuid16 == GN_SVCLASS_ID:
label = _("Group Network"
) if uuid16 == GN_SVCLASS_ID else _(
"Network Access _Point")
item = create_menuitem(
label, get_icon("network-wireless", 16))
manager_menu.Signals.Handle(
"gobject", item, "activate",
manager_menu.on_connect, device, name, uuid)
item.show()
items.append((item, 80))
else:
item = create_menuitem(_("Network"),
get_x_icon("network-wireless", 16))
manager_menu.Signals.Handle("gobject", item, "activate",
manager_menu.on_disconnect,
device, name)
item.show()
items.append((item, 101))
if "DhcpClient" in appl.QueryPlugins():
def renew(x):
appl.DhcpClient(sprops["Interface"])
item = create_menuitem(_("Renew IP Address"),
get_icon("view-refresh", 16))
manager_menu.Signals.Handle("gobject", item,
"activate", renew)
item.show()
items.append((item, 201))
return items
class ManagerDeviceMenu(Gtk.Menu):
__ops__ = {}
__instances__ = []
def __init__(self, blueman):
super(ManagerDeviceMenu, self).__init__()
self.set_name("ManagerDeviceMenu")
self.Blueman = blueman
self.SelectedDevice = None
self.is_popup = False
self._device_property_changed_signal = self.Blueman.List.connect(
"device-property-changed", self.on_device_property_changed)
self._selection_done_signal = None
ManagerDeviceMenu.__instances__.append(self)
self._any_network = AnyNetwork()
self._any_network.connect_signal('property-changed',
self._on_service_property_changed)
self._any_device = AnyDevice()
self._any_device.connect_signal('property-changed',
self._on_service_property_changed)
try:
self._appl = AppletService()
except Exception:
logging.error("** Failed to connect to applet", exc_info=True)
self._appl = None
self.Generate()
def __del__(self):
logging.debug("deleting devicemenu")
def popup(self, *args):
self.is_popup = True
if not self._device_property_changed_signal:
self._device_property_changed_signal = self.Blueman.List.connect(
"device-property-changed", self.on_device_property_changed)
if not self._selection_done_signal:
def disconnectall(x):
self.disconnect(self._device_property_changed_signal)
self.disconnect(self._selection_done_signal)
self._selection_done_signal = self.connect("selection-done",
disconnectall)
self.Generate()
super().popup(*args)
def clear(self):
def each(child, data):
self.remove(child)
child.destroy()
self.foreach(each, None)
def set_op(self, device, message):
ManagerDeviceMenu.__ops__[device.get_object_path()] = message
for inst in ManagerDeviceMenu.__instances__:
logging.info("op: regenerating instance %s" % inst)
if inst.SelectedDevice == self.SelectedDevice and not (
inst.is_popup and not inst.props.visible):
inst.Generate()
def get_op(self, device):
try:
return ManagerDeviceMenu.__ops__[device.get_object_path()]
except KeyError:
return None
def unset_op(self, device):
del ManagerDeviceMenu.__ops__[device.get_object_path()]
for inst in ManagerDeviceMenu.__instances__:
logging.info("op: regenerating instance %s" % inst)
if inst.SelectedDevice == self.SelectedDevice and not (
inst.is_popup and not inst.props.visible):
inst.Generate()
def _on_service_property_changed(self, _service, key, _value, _path):
if key == "Connected":
self.Generate()
def on_connect(self, _item, service):
device = service.device
def success(obj, result, _user_data):
logging.info("success")
prog.message(_("Success!"))
if isinstance(service, SerialPort
) and SERIAL_PORT_SVCLASS_ID == service.short_uuid:
MessageArea.show_message(
_("Serial port connected to %s") % result, None,
"dialog-information")
else:
MessageArea.close()
self.unset_op(device)
def fail(obj, result, _user_data):
prog.message(_("Failed"))
self.unset_op(device)
logging.warning("fail %s" % result)
msg, tb = e_(result.message)
MessageArea.show_message(_("Connection Failed: ") + msg, tb)
self.set_op(device, _("Connecting..."))
prog = ManagerProgressbar(self.Blueman, False)
if self._appl is None:
fail(None, GLib.Error('Applet DBus Service not available'), None)
return
try:
self._appl.SetTimeHint('(u)', Gtk.get_current_event_time())
except Exception as e:
logging.exception(e)
self._appl.connect_service('(os)',
device.get_object_path(),
service.uuid,
result_handler=success,
error_handler=fail,
timeout=GLib.MAXINT)
prog.start()
def on_disconnect(self, item, service, port=0):
def ok(obj, result, user_date):
logging.info("disconnect success")
self.Generate()
def err(obj, result, user_date):
logging.warning("disconnect failed %s" % result)
msg, tb = e_(result.message)
MessageArea.show_message(_("Disconnection Failed: ") + msg, tb)
self.Generate()
if self._appl is None:
err(None, GLib.Error('Applet DBus Service not available'), None)
return
self._appl.disconnect_service('(osd)',
service.device.get_object_path(),
service.uuid,
port,
result_handler=ok,
error_handler=err)
def on_device_property_changed(self, List, device, tree_iter, key_value):
key, value = key_value
# print "menu:", key, value
if List.compare(tree_iter, List.selected()):
if key in ("Connected", "UUIDs", "Trusted", "Paired"):
self.Generate()
def _generic_connect(self, item, device, connect):
def fail(obj, result, user_date):
logging.info("fail", result)
prog.message(_("Failed"))
self.unset_op(device)
msg, tb = e_(result.message)
MessageArea.show_message(_("Connection Failed: ") + msg)
def success(obj, result, user_data):
logging.info("success")
prog.message(_("Success!"))
MessageArea.close()
self.unset_op(device)
if connect:
self.set_op(self.SelectedDevice, _("Connecting..."))
self._appl.connect_service("(os)",
device.get_object_path(),
'00000000-0000-0000-0000-000000000000',
result_handler=success,
error_handler=fail,
timeout=GLib.MAXINT)
else:
self.set_op(self.SelectedDevice, _("Disconnecting..."))
self._appl.disconnect_service(
"(osd)",
device.get_object_path(),
'00000000-0000-0000-0000-000000000000',
0,
result_handler=success,
error_handler=fail,
timeout=GLib.MAXINT)
prog = ManagerProgressbar(self.Blueman, False)
prog.start()
def Generate(self):
self.clear()
items = []
if not self.is_popup or self.props.visible:
selected = self.Blueman.List.selected()
if not selected:
return
row = self.Blueman.List.get(selected, "alias", "paired",
"connected", "trusted", "objpush",
"device")
else:
(x, y) = self.Blueman.List.get_pointer()
path = self.Blueman.List.get_path_at_pos(x, y)
if path is not None:
row = self.Blueman.List.get(path[0], "alias", "paired",
"connected", "trusted", "objpush",
"device")
else:
return
self.SelectedDevice = row["device"]
op = self.get_op(self.SelectedDevice)
if op is not None:
item = create_menuitem(op, "network-transmit-recieve")
item.props.sensitive = False
item.show()
self.append(item)
return
# Generic (dis)connect
# LE devices do not appear to expose certain properties like uuids until connect to at least once.
# show generic connect for these as we will not show any way to connect otherwise.
device_uuids = self.SelectedDevice['UUIDs']
show_generic_connect = not device_uuids
for uuid in device_uuids:
service_uuid = ServiceUUID(uuid)
if service_uuid.short_uuid in (AUDIO_SOURCE_SVCLASS_ID,
AUDIO_SINK_SVCLASS_ID,
HANDSFREE_AGW_SVCLASS_ID,
HANDSFREE_SVCLASS_ID,
HEADSET_SVCLASS_ID, HID_SVCLASS_ID,
0x1812):
show_generic_connect = True
break
elif not service_uuid.reserved:
show_generic_connect = uuid == '03b80e5a-ede8-4b33-a751-6ce34ec4c700'
break
if not row["connected"] and show_generic_connect:
connect_item = create_menuitem(_("_Connect"), "blueman")
connect_item.connect("activate", self._generic_connect,
self.SelectedDevice, True)
connect_item.props.tooltip_text = _(
"Connects auto connect profiles A2DP source, A2DP sink, and HID"
)
connect_item.show()
self.append(connect_item)
elif show_generic_connect:
connect_item = create_menuitem(_("_Disconnect"), "network-offline")
connect_item.props.tooltip_text = _(
"Forcefully disconnect the device")
connect_item.connect("activate", self._generic_connect,
self.SelectedDevice, False)
connect_item.show()
self.append(connect_item)
rets = self.Blueman.Plugins.Run("on_request_menu_items", self,
self.SelectedDevice)
for ret in rets:
if ret:
for (item, pos) in ret:
items.append((pos, item))
logging.debug(row["alias"])
have_disconnectables = False
have_connectables = False
if True in map(lambda x: 100 <= x[0] < 200, items):
have_disconnectables = True
if True in map(lambda x: x[0] < 100, items):
have_connectables = True
if True in map(lambda x: x[0] >= 200,
items) and (have_connectables or have_disconnectables):
item = Gtk.SeparatorMenuItem()
item.show()
items.append((199, item))
if have_connectables:
item = Gtk.MenuItem()
label = Gtk.Label()
label.set_markup(_("<b>Connect To:</b>"))
label.props.xalign = 0.0
label.show()
item.add(label)
item.props.sensitive = False
item.show()
items.append((0, item))
if have_disconnectables:
item = Gtk.MenuItem()
label = Gtk.Label()
label.set_markup(_("<b>Disconnect:</b>"))
label.props.xalign = 0.0
label.show()
item.add(label)
item.props.sensitive = False
item.show()
items.append((99, item))
items.sort(key=itemgetter(0))
for priority, item in items:
self.append(item)
if items:
item = Gtk.SeparatorMenuItem()
item.show()
self.append(item)
del items
send_item = create_menuitem(_("Send a _File..."), "edit-copy")
send_item.props.sensitive = False
self.append(send_item)
send_item.show()
if row["objpush"]:
send_item.connect("activate",
lambda x: self.Blueman.send(self.SelectedDevice))
send_item.props.sensitive = True
item = Gtk.SeparatorMenuItem()
item.show()
self.append(item)
item = create_menuitem(_("_Pair"), "dialog-password")
item.props.tooltip_text = _("Create pairing with the device")
self.append(item)
item.show()
if not row["paired"]:
item.connect("activate",
lambda x: self.Blueman.bond(self.SelectedDevice))
else:
item.props.sensitive = False
if not row["trusted"]:
item = create_menuitem(_("_Trust"), "blueman-trust")
item.connect(
"activate",
lambda x: self.Blueman.toggle_trust(self.SelectedDevice))
self.append(item)
item.show()
else:
item = create_menuitem(_("_Untrust"), "blueman-untrust")
self.append(item)
item.connect(
"activate",
lambda x: self.Blueman.toggle_trust(self.SelectedDevice))
item.show()
item.props.tooltip_text = _("Mark/Unmark this device as trusted")
item = create_menuitem(_("_Setup..."), "document-properties")
self.append(item)
item.connect("activate",
lambda x: self.Blueman.setup(self.SelectedDevice))
item.show()
item.props.tooltip_text = _("Run the setup assistant for this device")
def on_rename(_item, device):
def on_response(dialog, response_id):
if response_id == Gtk.ResponseType.ACCEPT:
device.set('Alias', alias_entry.get_text())
elif response_id == 1:
device.set('Alias', '')
dialog.destroy()
builder = Gtk.Builder()
builder.set_translation_domain("blueman")
bind_textdomain_codeset("blueman", "UTF-8")
builder.add_from_file(UI_PATH + "/rename-device.ui")
dialog = builder.get_object("dialog")
dialog.set_transient_for(self.Blueman)
dialog.props.icon_name = "blueman"
alias_entry = builder.get_object("alias_entry")
alias_entry.set_text(device['Alias'])
dialog.connect("response", on_response)
dialog.present()
item = Gtk.MenuItem.new_with_mnemonic("R_ename device...")
item.connect('activate', on_rename, self.SelectedDevice)
self.append(item)
item.show()
item = Gtk.SeparatorMenuItem()
item.show()
self.append(item)
item = create_menuitem(_("_Remove..."), "edit-delete")
item.connect("activate",
lambda x: self.Blueman.remove(self.SelectedDevice))
self.append(item)
item.show()
item.props.tooltip_text = _(
"Remove this device from the known devices list")
def on_connect(self, item, device, service_id, *args):
def success(*args2):
try:
uuid16 = sdp_get_serial_type(device.Address, args[0])
except:
uuid16 = 0
dprint("success", args2)
prog.message(_("Success!"))
if service_id == "serial" and SERIAL_PORT_SVCLASS_ID in uuid16:
MessageArea.show_message(
_("Serial port connected to %s") % args2[0],
gtk.STOCK_DIALOG_INFO)
else:
MessageArea.close()
self.unset_op(device)
def fail(*args):
prog.message(_("Failed"))
self.unset_op(device)
dprint("fail", args)
MessageArea.show_message(
_("Connection Failed: ") + e_(str(args[0])))
def cancel(prog, *args):
try:
svc.Disconnect(*args)
except:
pass
prog.message(_("Cancelled"))
self.unset_op(device)
svc = device.Services[service_id]
self.set_op(device, _("Connecting..."))
prog = ManagerProgressbar(self.Blueman, False)
try:
appl = AppletService()
except:
dprint("** Failed to connect to applet")
fail()
return
try:
appl.SetTimeHint(gtk.get_current_event_time())
except:
pass
if service_id == "network":
uuid = args[0]
appl.ServiceProxy(svc.GetInterfaceName(),
svc.GetObjectPath(),
"Connect", [uuid],
reply_handler=success,
error_handler=fail,
timeout=200)
#prog.set_cancellable(True)
#prog.connect("cancelled", cancel)
elif service_id == "input":
appl.ServiceProxy(svc.GetInterfaceName(),
svc.GetObjectPath(),
"Connect", [],
reply_handler=success,
error_handler=fail,
timeout=200)
#prog.connect("cancelled", cancel)
elif service_id == "serial":
uuid = str(args[0])
appl.RfcommConnect(device.GetObjectPath(),
uuid,
reply_handler=success,
error_handler=fail,
timeout=200)
else:
appl.ServiceProxy(svc.GetInterfaceName(),
svc.GetObjectPath(),
"Connect", [],
reply_handler=success,
error_handler=fail,
timeout=200)
prog.start()
def on_request_menu_items_bluez4(self, manager_menu, device):
# BlueZ 4 only
items = []
uuids = device.UUIDs
appl = AppletService()
for name, service in device.Services.items():
if name == "serial":
ports_list = rfcomm_list()
def flt(dev):
if dev["dst"] == device.Address and dev[
"state"] == "connected":
return dev["channel"]
active_ports = map(flt, ports_list)
def get_port_id(channel):
for dev in ports_list:
if dev["dst"] == device.Address and dev[
"state"] == "connected" and dev[
"channel"] == channel:
return dev["id"]
serial_items = []
num_ports = 0
has_dun = False
try:
for port_name, channel, uuid in sdp_get_cached_rfcomm(
device.Address):
if SERIAL_PORT_SVCLASS_ID in uuid:
if name is not None:
if channel in active_ports:
item = create_menuitem(
port_name,
get_x_icon("blueman-serial", 16))
manager_menu.Signals.Handle(
"gobject", item, "activate",
manager_menu.on_disconnect, device,
name,
"/dev/rfcomm%d" % get_port_id(channel))
item.show()
items.append((item, 150))
else:
item = create_menuitem(
port_name,
get_icon("blueman-serial", 16))
manager_menu.Signals.Handle(
"gobject", item, "activate",
manager_menu.on_connect, device, name,
channel)
item.show()
serial_items.append(item)
elif DIALUP_NET_SVCLASS_ID in uuid:
if name is not None:
if channel in active_ports:
item = create_menuitem(
port_name, get_x_icon("modem", 16))
manager_menu.Signals.Handle(
"gobject", item, "activate",
manager_menu.on_disconnect, device,
name,
"/dev/rfcomm%d" % get_port_id(channel))
item.show()
items.append((item, 150))
else:
item = create_menuitem(
port_name, get_icon("modem", 16))
manager_menu.Signals.Handle(
"gobject", item, "activate",
manager_menu.on_connect, device, name,
channel)
item.show()
serial_items.append(item)
has_dun = True
except KeyError:
for uuid in uuids:
uuid16 = uuid128_to_uuid16(uuid)
if uuid16 == DIALUP_NET_SVCLASS_ID:
item = create_menuitem(_("Dialup Service"),
get_icon("modem", 16))
manager_menu.Signals.Handle(
"gobject", item, "activate",
manager_menu.on_connect, device, name, uuid)
item.show()
serial_items.append(item)
has_dun = True
if uuid16 == SERIAL_PORT_SVCLASS_ID:
item = create_menuitem(
_("Serial Service"),
get_icon("blueman-serial", 16))
manager_menu.Signals.Handle(
"gobject", item, "activate",
manager_menu.on_connect, device, name, uuid)
item.show()
serial_items.append(item)
for dev in ports_list:
if dev["dst"] == device.Address:
if dev["state"] == "connected":
devname = _(
"Serial Port %s") % "rfcomm%d" % dev["id"]
item = create_menuitem(devname,
get_x_icon("modem", 16))
manager_menu.Signals.Handle(
"gobject", item, "activate",
manager_menu.on_disconnect, device, name,
"/dev/rfcomm%d" % dev["id"])
items.append((item, 120))
item.show()
def open_settings(i, device):
from blueman.gui.GsmSettings import GsmSettings
d = GsmSettings(device.Address)
d.run()
d.destroy()
if has_dun and "PPPSupport" in appl.QueryPlugins():
item = Gtk.SeparatorMenuItem()
item.show()
serial_items.append(item)
item = create_menuitem(_("Dialup Settings"),
get_icon("preferences-desktop", 16))
serial_items.append(item)
item.show()
manager_menu.Signals.Handle("gobject", item, "activate",
open_settings, device)
if len(serial_items) > 1:
sub = Gtk.Menu()
sub.show()
item = create_menuitem(_("Serial Ports"),
get_icon("modem", 16))
item.set_submenu(sub)
item.show()
items.append((item, 90))
for item in serial_items:
sub.append(item)
else:
for item in serial_items:
items.append((item, 80))
elif name == "network":
manager_menu.Signals.Handle(
"bluez", service, manager_menu.service_property_changed,
"PropertyChanged")
sprops = service.get_properties()
if not sprops["Connected"]:
for uuid in uuids:
uuid16 = uuid128_to_uuid16(uuid)
if uuid16 == GN_SVCLASS_ID:
item = create_menuitem(
_("Group Network"),
get_icon("network-wireless", 16))
manager_menu.Signals.Handle(
"gobject", item, "activate",
manager_menu.on_connect, device, name, uuid)
item.show()
items.append((item, 80))
if uuid16 == NAP_SVCLASS_ID:
item = create_menuitem(
_("Network Access Point"),
get_icon("network-wireless", 16))
manager_menu.Signals.Handle(
"gobject", item, "activate",
manager_menu.on_connect, device, name, uuid)
item.show()
items.append((item, 81))
else:
item = create_menuitem(_("Network"),
get_x_icon("network-wireless", 16))
manager_menu.Signals.Handle("gobject", item, "activate",
manager_menu.on_disconnect,
device, name)
item.show()
items.append((item, 101))
if "DhcpClient" in appl.QueryPlugins():
def renew(x):
appl.DhcpClient(sprops["Interface"])
item = create_menuitem(_("Renew IP Address"),
get_icon("view-refresh", 16))
manager_menu.Signals.Handle("gobject", item,
"activate", renew)
item.show()
items.append((item, 201))
elif name == "input":
manager_menu.Signals.Handle(
"bluez", service, manager_menu.service_property_changed,
"PropertyChanged")
sprops = service.get_properties()
if sprops["Connected"]:
item = create_menuitem(_("Input Service"),
get_x_icon("mouse", 16))
manager_menu.Signals.Handle("gobject", item, "activate",
manager_menu.on_disconnect,
device, name)
items.append((item, 100))
else:
item = create_menuitem(_("Input Service"),
get_icon("mouse", 16))
manager_menu.Signals.Handle("gobject", item, "activate",
manager_menu.on_connect,
device, name)
items.append((item, 1))
item.show()
elif name == "headset":
sprops = service.get_properties()
if sprops["Connected"]:
item = create_menuitem(_("Headset Service"),
get_icon("blueman-handsfree", 16))
manager_menu.Signals.Handle("gobject", item, "activate",
manager_menu.on_disconnect,
device, name)
items.append((item, 110))
else:
item = create_menuitem(_("Headset Service"),
get_icon("blueman-handsfree", 16))
manager_menu.Signals.Handle("gobject", item, "activate",
manager_menu.on_connect,
device, name)
items.append((item, 10))
item.show()
elif name == "audiosink":
sprops = service.get_properties()
if sprops["Connected"]:
item = create_menuitem(_("Audio Sink"),
get_icon("blueman-headset", 16))
manager_menu.Signals.Handle("gobject", item, "activate",
manager_menu.on_disconnect,
device, name)
items.append((item, 120))
else:
item = create_menuitem(_("Audio Sink"),
get_icon("blueman-headset", 16))
item.props.tooltip_text = _(
"Allows to send audio to remote device")
manager_menu.Signals.Handle("gobject", item, "activate",
manager_menu.on_connect,
device, name)
items.append((item, 20))
item.show()
elif name == "audiosource":
sprops = service.get_properties()
if not sprops["State"] == "disconnected":
item = create_menuitem(_("Audio Source"),
get_icon("blueman-headset", 16))
manager_menu.Signals.Handle("gobject", item, "activate",
manager_menu.on_disconnect,
device, name)
items.append((item, 121))
else:
item = create_menuitem(_("Audio Source"),
get_icon("blueman-headset", 16))
item.props.tooltip_text = _(
"Allows to receive audio from remote device")
manager_menu.Signals.Handle("gobject", item, "activate",
manager_menu.on_connect,
device, name)
items.append((item, 21))
item.show()
return items
def on_request_menu_items(self, manager_menu, device):
items = []
appl = AppletService()
self.has_dun = False
serial_items = []
def add_menu_item(manager_menu, service):
if service.connected:
item = create_menuitem(service.name, get_x_icon(service.icon, 16))
item.connect("activate", manager_menu.on_disconnect, service)
items.append((item, service.priority + 100))
else:
item = create_menuitem(service.name, get_icon(service.icon, 16))
if service.description:
item.props.tooltip_text = service.description
item.connect("activate", manager_menu.on_connect, service)
if service.group == 'serial':
serial_items.append(item)
if isinstance(service, DialupNetwork):
self.has_dun = True
else:
items.append((item, service.priority))
item.show()
for service in device.get_services():
try:
add_menu_item(manager_menu, service)
except Exception as e:
dprint("Failed to load service %s" % service.name)
traceback.print_exc()
continue
if service.group == 'serial':
for dev in rfcomm_list():
if dev["dst"] == device.Address and dev["state"] == "connected":
devname = _("Serial Port %s") % "rfcomm%d" % dev["id"]
item = create_menuitem(devname, get_x_icon("modem", 16))
item.connect("activate", manager_menu.on_disconnect, service, dev["id"])
items.append((item, 120))
item.show()
if service.group == 'network' and service.connected:
if "DhcpClient" in appl.QueryPlugins():
def renew(x):
appl.DhcpClient(Network(device.get_object_path()).get_properties()["Interface"])
item = create_menuitem(_("Renew IP Address"), get_icon("view-refresh", 16))
item.connect("activate", renew)
item.show()
items.append((item, 201))
if self.has_dun and "PPPSupport" in appl.QueryPlugins():
def open_settings(i, device):
from blueman.gui.GsmSettings import GsmSettings
d = GsmSettings(device.Address)
d.run()
d.destroy()
item = Gtk.SeparatorMenuItem()
item.show()
serial_items.append(item)
item = create_menuitem(_("Dialup Settings"), get_icon("gtk-preferences", 16))
serial_items.append(item)
item.show()
item.connect("activate", open_settings, device)
if len(serial_items) > 1:
sub = Gtk.Menu()
sub.show()
item = create_menuitem(_("Serial Ports"), get_icon("modem", 16))
item.set_submenu(sub)
item.show()
items.append((item, 90))
for item in serial_items:
sub.append(item)
else:
for item in serial_items:
items.append((item, 80))
return items
def on_connect(self, item, device, service_id=None, *args):
def success(*args2):
try:
uuid16 = sdp_get_serial_type(device.Address, args[0])
except:
uuid16 = 0
dprint("success", args2)
prog.message(_("Success!"))
if service_id == "serial" and SERIAL_PORT_SVCLASS_ID in uuid16:
MessageArea.show_message(
_("Serial port connected to %s") % args2[0],
"dialog-information")
else:
MessageArea.close()
self.unset_op(device)
def fail(*args):
prog.message(_("Failed"))
self.unset_op(device)
dprint("fail", args)
MessageArea.show_message(
_("Connection Failed: ") + e_(str(args[0])))
self.set_op(device, _("Connecting..."))
prog = ManagerProgressbar(self.Blueman, False)
try:
appl = AppletService()
except:
dprint("** Failed to connect to applet")
fail()
return
try:
appl.SetTimeHint(Gtk.get_current_event_time())
except:
pass
if service_id:
svc = device.Services[service_id]
if service_id == "network":
uuid = args[0]
appl.ServiceProxy(svc.get_interface_name(),
svc.get_object_path(),
"Connect", [uuid],
reply_handler=success,
error_handler=fail,
timeout=200)
elif service_id == "input":
appl.ServiceProxy(svc.get_interface_name(),
svc.get_object_path(),
"Connect", [],
reply_handler=success,
error_handler=fail,
timeout=200)
elif service_id == "serial":
uuid = str(args[0])
appl.RfcommConnect(device.get_object_path(),
uuid,
reply_handler=success,
error_handler=fail,
timeout=200)
else:
appl.ServiceProxy(svc.get_interface_name(),
svc.get_object_path(),
"Connect", [],
reply_handler=success,
error_handler=fail,
timeout=200)
else:
appl.ServiceProxy(device.get_interface_name(),
device.get_object_path(),
'Connect', [],
reply_handler=success,
error_handler=fail,
timeout=200)
prog.start()
