def __init__(self, service_name, obj_path):
self.bus = dbus.SessionBus()
self._signals = SignalTracker()
service = self.bus.get_object("org.openobex", obj_path)
GObject.GObject.__init__(self)
dbus.proxies.Interface.__init__(self, service, service_name)
def on_load(self, applet):
GObject.GObject.__init__(self)
self.monitors = []
self.devices = weakref.WeakValueDictionary()
self.signals = SignalTracker()
bus = self.bus = dbus.SystemBus()
self.signals.Handle('bluez',
Network(),
self.on_network_property_changed,
'PropertyChanged',
path_keyword="path")
item = create_menuitem(_("Network _Usage"),
get_icon("network-wireless", 16))
item.props.tooltip_text = _("Shows network traffic usage")
self.signals.Handle(item, "activate", self.activate_ui)
self.Applet.Plugins.Menu.Register(self, item, 84, True)
self.signals.Handle("dbus",
bus,
self.on_nm_ppp_stats,
"PppStats",
"org.freedesktop.NetworkManager.Device.Serial",
path_keyword="path")
self.nm_paths = {}
class OdsBase(dbus.proxies.Interface, GObject.GObject):
# def OdsMethod(fn):
# def new(self, *args, **kwargs):
# fn(self, *args, **kwargs)
# getattr(super(OdsBase,self), fn.__name__)(*args, **kwargs)
# return new
def __init__(self, service_name, obj_path):
self.bus = dbus.SessionBus()
self._signals = SignalTracker()
service = self.bus.get_object("org.openobex", obj_path)
GObject.GObject.__init__(self)
dbus.proxies.Interface.__init__(self, service, service_name)
def DisconnectAll(self):
self._signals.DisconnectAll()
def Handle(self, signame, handler):
self._signals.Handle("dbus", self.bus, handler, signame,
self.dbus_interface, None, self.object_path)
def GHandle(self, *args):
self._signals.Handle("gobject", self, *args)
def on_load(self, applet):
self.num_connections = 0
self.active = False
self.initialized = False
self.signals = SignalTracker()
self.signals.Handle('bluez', bluez.Device(), self.on_device_property_changed, 'PropertyChanged')
def on_load(self, applet):
self.bus = dbus.SystemBus()
self.nma = None
self.nm = None
self.nm_signals = SignalTracker()
self.nma_signals = SignalTracker()
self.watches = [
self.bus.watch_name_owner("org.freedesktop.NetworkManager",
self.on_nm_owner_changed)
]
self.legacy = self.bus.name_has_owner(
'org.freedesktop.NetworkManagerUserSettings')
if self.legacy:
self.watches.append(
self.bus.watch_name_owner(
"org.freedesktop.NetworkManagerUserSettings",
self.on_nma_owner_changed))
self.settings_bus = 'org.freedesktop.NetworkManagerUserSettings'
self.settings_interface = 'org.freedesktop.NetworkManagerSettings'
self.connection_settings_interface = 'org.freedesktop.NetworkManagerSettings.Connection'
self.settings_path = "/org/freedesktop/NetworkManagerSettings"
NewConnectionBuilder.DEVICE_STATE_DISCONNECTED = 3
NewConnectionBuilder.DEVICE_STATE_ACTIVATED = 8
NewConnectionBuilder.DEVICE_STATE_FAILED = 9
else:
self.settings_bus = 'org.freedesktop.NetworkManager'
self.settings_interface = 'org.freedesktop.NetworkManager.Settings'
self.connection_settings_interface = 'org.freedesktop.NetworkManager.Settings.Connection'
self.settings_path = "/org/freedesktop/NetworkManager/Settings"
def on_load(self, applet):
AppletPlugin.add_method(self.on_power_state_query)
AppletPlugin.add_method(self.on_power_state_change_requested)
AppletPlugin.add_method(self.on_power_state_changed)
self.Applet = applet
self.item = create_menuitem("Should be overwritten", get_icon("blueman-disabled", 16))
self.item.get_child().get_children()[1].set_markup_with_mnemonic(_("<b>Bluetooth _Off</b>"))
self.item.props.tooltip_text = _("Turn off all adapters")
self.signals = SignalTracker()
self.signals.Handle('bluez', Bluez.Adapter(), self.adapter_property_changed, "PropertyChanged",
path_keyword="path")
self.signals.Handle(self.item, "activate", lambda x: self.on_bluetooth_toggled())
self.Applet.Plugins.Menu.Register(self, self.item, 0)
self.adapter_state = True
self.current_state = True
self.request_in_progress = False
self.STATE_ON = 2
self.STATE_OFF = 1
self.STATE_OFF_FORCED = 0
def __init__(self, parent, params, ok_cb, err_cb):
self.parent = parent
self.params = params
self.ok_cb = ok_cb
self.err_cb = err_cb
self.signals = SignalTracker()
self.device = None
self.connection = None
self.signals.Handle("dbus", parent.bus, self.on_nm_device_added,
"DeviceAdded", "org.freedesktop.NetworkManager")
self.signals.Handle("dbus", parent.bus, self.on_nma_new_connection,
"NewConnection",
"org.freedesktop.NetworkManagerSettings")
self.device = self.parent.find_device(params["bluetooth"]["bdaddr"])
self.connection = self.parent.find_connection(
params["bluetooth"]["bdaddr"], "panu")
if not self.connection:
parent.add_connection(params)
GObject.timeout_add(1000, self.signal_wait_timeout)
else:
self.init_connection()
def on_load(self, applet):
self.Signals = SignalTracker()
self.Signals.Handle('bluez',
Network(),
self.on_network_prop_changed,
'PropertyChanged',
path_keyword='path')
def __init__(self):
SignalTracker.__init__(self)
self.bus = dbus.SessionBus()
service = self.bus.get_object("org.blueman.Applet",
"/",
follow_name_owner_changes=True)
dbus.proxies.Interface.__init__(self, service, "org.blueman.Applet")
def on_load(self, applet):
self.num_connections = 0
self.active = False
self.initialized = False
self.signals = SignalTracker()
self.signals.Handle("dbus", dbus.SystemBus(),
self.on_device_property_changed, "PropertyChanged",
"org.bluez.Device")
def on_load(self, applet):
self.Applet = applet
self.Signals = SignalTracker()
self.Config = Config("org.blueman.network")
self.Signals.Handle("gobject", self.Config, "changed",
self.on_config_changed)
self.load_nap_settings()
def on_load(self, applet):
self.signals = SignalTracker()
self.signals.Handle('bluez',
Bluez.Device(),
self.on_device_property_changed,
'PropertyChanged',
path_keyword="path")
self.scripts = {}
def on_load(self, applet):
self.signals = SignalTracker()
self.signals.Handle("dbus",
dbus.SystemBus(),
self.on_device_property_changed,
"PropertyChanged",
"org.bluez.Device",
path_keyword="path")
self.scripts = {}
class GameControllerWakelock(AppletPlugin):
__description__ = _("Temporarily suspends the screensaver when a bluetooth game controller is connected.")
__author__ = "bwRavencl"
__icon__ = "input-gaming"
def on_load(self, applet):
self.wake_lock = 0
self.root_window_id = "0x%x" % Gdk.Screen.get_default().get_root_window().get_xid()
self.signals = SignalTracker()
self.signals.Handle("bluez", bluez.Device(), self.on_device_property_changed, "PropertyChanged", path_keyword="path")
def on_unload(self):
if self.wake_lock:
self.wake_lock = 1
self.suspend_screensaver("resume")
self.signals.DisconnectAll()
def on_device_property_changed(self, key, value, path):
if key == "Connected":
klass = Device(path).get_properties()["Class"] & 0x1fff
if klass == 0x504 or klass == 0x508:
if value:
self.xdg_screensaver("suspend")
else:
self.xdg_screensaver("resume")
def xdg_screensaver(self, action):
if action == "resume":
if self.wake_lock == 0:
pass
elif self.wake_lock > 1:
self.wake_lock -= 1
pass
elif action == "suspend" and self.wake_lock >= 1:
self.wake_lock += 1
pass
command = ["xdg-screensaver", action, self.root_window_id]
try:
process = subprocess.Popen(command, stderr=subprocess.PIPE)
_, stderr = process.communicate()
if process.returncode != 0:
dprint(" ".join(command) + " failed with: " + stderr)
pass
if action == "suspend":
self.wake_lock += 1
elif action == "resume":
self.wake_lock = 0
except:
dprint(traceback.format_exc())
def on_load(self, applet):
self.wake_lock = 0
self.root_window_id = "0x%x" % Gdk.Screen.get_default(
).get_root_window().get_xid()
self.signals = SignalTracker()
self.signals.Handle("bluez",
bluez.Device(),
self.on_device_property_changed,
"PropertyChanged",
path_keyword="path")
def on_load(self, applet):
self.bus = dbus.SystemBus()
self.nma = None
self.nm = None
self.nm_signals = SignalTracker()
self.nma_signals = SignalTracker()
self.watch1 = self.bus.watch_name_owner("org.freedesktop.NetworkManagerUserSettings", self.on_nma_owner_changed)
self.watch2 = self.bus.watch_name_owner("org.freedesktop.NetworkManager", self.on_nm_owner_changed)
self.client = gconf.client_get_default ()
def __init__(self, blueman, cancellable=True, text=_("Connecting")):
def on_enter(evbox, event):
c = Gdk.Cursor.new(Gdk.CursorType.HAND2)
self.window.get_window().set_cursor(c)
def on_leave(evbox, event):
self.window.get_window().set_cursor(None)
def on_clicked(evbox, event):
self.eventbox.props.sensitive = False
self.emit("cancelled")
GObject.GObject.__init__(self)
self.Blueman = blueman
self.cancellable = cancellable
self.hbox = hbox = blueman.Builder.get_object("statusbar1")
self.progressbar = Gtk.ProgressBar()
self.signals = SignalTracker()
self.button = Gtk.Image.new_from_pixbuf(get_icon("process-stop", 16))
self.eventbox = eventbox = Gtk.EventBox()
eventbox.add(self.button)
eventbox.props.tooltip_text = _("Cancel Operation")
self.signals.Handle(eventbox, "enter-notify-event", on_enter)
self.signals.Handle(eventbox, "leave-notify-event", on_leave)
self.signals.Handle(eventbox, "button-press-event", on_clicked)
self.progressbar.set_size_request(100, 15)
self.progressbar.set_ellipsize(Pango.EllipsizeMode.END)
self.progressbar.set_text(text)
self.progressbar.set_pulse_step(0.05)
self.window = blueman.Builder.get_object("window")
hbox.pack_end(eventbox, True, False, 0)
hbox.pack_end(self.progressbar, False, False, 0)
if ManagerProgressbar.__instances__ != []:
dprint("hiding", ManagerProgressbar.__instances__[-1])
ManagerProgressbar.__instances__[-1].hide()
self.show()
if not self.cancellable:
self.eventbox.props.sensitive = False
self.gsource = None
self.finalized = False
ManagerProgressbar.__instances__.append(self)
def __init__(self, plugin):
Monitor.__id__ += 1
self.inst_id = "/inst%d" % Monitor.__id__
self.plugin = plugin
self.sigs = SignalTracker()
self.bus = dbus.SessionBus()
dbus.service.Object.__init__(self)
self.add_to_connection(self.bus, self.inst_id)
self.sigs.Handle("dbus", self.bus, self.on_value_changed, "ValueChanged", "org.blueman.Config")
def __init__(self, device, nm_dev_path):
MonitorBase.__init__(self, device, "NM")
dprint("created nm monitor for path", nm_dev_path)
self.signals = SignalTracker()
self.signals.Handle("dbus",
dbus.SystemBus(),
self.on_ppp_stats,
"PppStats",
"org.freedesktop.NetworkManager.Device.Serial",
path=nm_dev_path)
self.signals.Handle(device, "property-changed", self.on_device_property_changed)
def on_load(self, applet):
self.Signals = SignalTracker()
self.add_dbus_method(self.DhcpClient, in_signature="s")
self.Signals.Handle('bluez',
Network(),
self.on_network_prop_changed,
'PropertyChanged',
path_keyword="path")
self.quering = []
def on_load(self, applet):
self.Signals = SignalTracker()
self.add_dbus_method(self.DhcpClient, in_signature="s")
self.Signals.Handle("dbus",
dbus.SystemBus(),
self.on_network_prop_changed,
"PropertyChanged",
"org.bluez.Network",
path_keyword="path")
self.quering = []
class Monitor(dbus.service.Object):
__id__ = 0
def __init__(self, plugin):
Monitor.__id__ += 1
self.inst_id = "/inst%d" % Monitor.__id__
self.plugin = plugin
self.sigs = SignalTracker()
self.bus = dbus.SessionBus()
dbus.service.Object.__init__(self)
self.add_to_connection(self.bus, self.inst_id)
self.sigs.Handle("dbus", self.bus, self.on_value_changed,
"ValueChanged", "org.blueman.Config")
def on_value_changed(self, section, data):
s = "".join(chr(b) for b in data)
(key, value) = pickle.loads(s)
key = str(key)
if self.plugin().section == section:
self.plugin().set(key, value, True)
else:
if not section in File.__db__:
File.__db__[section] = {}
File.__db__[section][key] = value
@dbus.service.signal(dbus_interface="org.blueman.Config", signature='say')
def ValueChanged(self, section, data):
pass
def on_load(self, applet):
self.Signals = SignalTracker()
self.item = create_menuitem(_("_Make Discoverable"),
get_icon("gtk-find", 16))
applet.Plugins.Menu.Register(self, self.item, 20, False)
self.Applet = applet
self.adapter = None
self.time_left = -1
self.Signals.Handle(self.item, "activate", self.on_set_discoverable)
self.item.props.tooltip_text = _(
"Make the default adapter temporarily visible")
self.timeout = None
def on_load(self, applet):
self.signals = SignalTracker()
if not self.get_option("checked"):
self.set_option("checked", True)
if not have("pactl"):
applet.Plugins.SetConfig("PulseAudio", False)
return
self.bus = dbus.SystemBus()
self.connected_sources = []
self.connected_sinks = []
self.connected_hs = []
self.loaded_modules = {}
self.pulse_utils = PulseAudioUtils()
version = self.pulse_utils.GetVersion()
dprint("PulseAudio version:", version)
if version[0] == 0:
if tuple(version) < (0, 9, 15):
raise Exception(
"PulseAudio too old, required 0.9.15 or higher")
self.signals.Handle("dbus",
self.bus,
self.on_sink_prop_change,
"PropertyChanged",
"org.bluez.AudioSink",
path_keyword="device")
self.signals.Handle("dbus",
self.bus,
self.on_source_prop_change,
"PropertyChanged",
"org.bluez.AudioSource",
path_keyword="device")
self.signals.Handle("dbus",
self.bus,
self.on_hsp_prop_change,
"PropertyChanged",
"org.bluez.Headset",
path_keyword="device")
self.signals.Handle(self.pulse_utils, "event", self.on_pulse_event)
def on_load(self, applet):
AppletPlugin.add_method(self.on_power_state_query)
AppletPlugin.add_method(self.on_power_state_change_requested)
AppletPlugin.add_method(self.on_power_state_changed)
self.add_dbus_method(self.SetBluetoothStatus,
in_signature="b",
out_signature="")
self.add_dbus_method(self.GetBluetoothStatus,
in_signature="",
out_signature="b")
self.BluetoothStatusChanged = self.add_dbus_signal(
"BluetoothStatusChanged", signature="b")
self.Applet = applet
self.item = create_menuitem(_("<b>Bluetooth Off</b>"),
get_icon("gtk-stop", 16))
self.item.get_child().set_markup(_("<b>Turn Bluetooth Off</b>"))
self.item.props.tooltip_text = _("Turn off all adapters")
self.signals = SignalTracker()
self.signals.Handle("dbus",
dbus.SystemBus(),
self.adapter_property_changed,
"PropertyChanged",
"org.bluez.Adapter",
"org.bluez",
path_keyword="path")
self.signals.Handle(self.item, "activate",
lambda x: self.on_bluetooth_toggled())
self.Applet.Plugins.Menu.Register(self, self.item, 0)
self.adapter_state = True
self.current_state = True
self.power_changeable = True
self.request_in_progress = False
self.STATE_ON = 2
self.STATE_OFF = 1
self.STATE_OFF_FORCED = 0
def __init__(self, blueman):
GObject.GObject.__init__(self)
self.Blueman = blueman
self.SelectedDevice = None
self.is_popup = False
#object, args,
self.Signals = SignalTracker()
self.MainSignals = SignalTracker()
self.MainSignals.Handle("gobject", self.Blueman.List, "device-property-changed",
self.on_device_property_changed)
ManagerDeviceMenu.__instances__.append(self)
self.Generate()
def Handle(self, signame, handler):
SignalTracker.Handle(self,
"dbus",
self.bus,
handler,
signame,
self.dbus_interface,
path=self.object_path)
def __init__(self, parent, service, ok_cb, err_cb):
self.parent = parent
self.ok_cb = ok_cb
self.err_cb = err_cb
self.signals = SignalTracker()
self.device = None
self.connection = None
self.signals.Handle("dbus", parent.bus, self.on_nm_device_added,
"DeviceAdded", "org.freedesktop.NetworkManager")
self.signals.Handle("dbus", parent.bus, self.on_nma_new_connection,
"NewConnection", self.parent.settings_interface)
self.device = self.parent.find_device(service.device.Address)
self.connection = self.parent.find_connection(service.device.Address,
"panu")
if not self.connection:
# This is for compatibility with network-manager < 0.9.8.6. Newer versions that support BlueZ 5 add a
# default connection automatically
addr_bytes = bytearray.fromhex(
str.replace(str(service.device.Address), ':', ' '))
parent.nma.AddConnection({
'connection': {
'id': '%s on %s' % (service.name, service.device.Alias),
'uuid': str(uuid1()),
'autoconnect': False,
'type': 'bluetooth'
},
'bluetooth': {
'bdaddr': dbus.ByteArray(addr_bytes),
'type': 'panu'
},
'ipv4': {
'method': 'auto'
},
'ipv6': {
'method': 'auto'
}
})
GObject.timeout_add(1000, self.signal_wait_timeout)
else:
self.init_connection()
def __init__(self, instance):
GObject.GObject.__init__(self)
self.Properties = {}
self.Fake = True
self.Temp = False
if isinstance(instance, str) or isinstance(instance, unicode):
self.Device = BluezDevice(instance)
else:
self.Device = instance
#set fallback icon, fixes lp:#327718
self.Device.Icon = "blueman"
self.Device.Class = "unknown"
self.__services = {}
self.Valid = True
self.Signals = SignalTracker()
dprint("caching initial properties")
self.Properties = self.Device.get_properties()
if not "Fake" in self.Properties:
self.Fake = False
w = weakref.ref(self)
if not self.Fake:
self._obj_path = self.Device.get_object_path()
self.Signals.Handle(
"bluez", self.Device,
lambda key, value: w() and w().property_changed(key, value),
"PropertyChanged")
object_path = self.Device.get_object_path()
adapter = Adapter(
object_path.replace("/" + os.path.basename(object_path), ""))
self.Signals.Handle(
"bluez", adapter,
lambda path: w() and w().on_device_removed(path),
"DeviceRemoved")
def __init__(self, parent, device, uuid, reply, err):
self.parent = parent
self.device = device
self.uuid = uuid
self.reply = reply
self.err = err
self.rfcomm_dev = None
self.timeout = None
self.signals = SignalTracker()
self.signals.Handle("dbus", self.parent.bus, self.on_mm_device_added,
"DeviceAdded", "org.freedesktop.ModemManager")
#for some reason these handlers take a reference and don't give it back
#so i have to workaround :(
w = weakref.ref(self)
device.Services["serial"].Connect(
uuid,
reply_handler=lambda *args: w() and w().on_connect_reply(*args),
error_handler=lambda *args: w() and w().on_connect_error(*args))
def __init__(self):
SignalTracker.__init__(self)
self.bus = dbus.SessionBus()
service = self.bus.get_object("org.blueman.Applet", "/", follow_name_owner_changes=True)
dbus.proxies.Interface.__init__(self, service, "org.blueman.Applet")
