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_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()