def make_discoverable(self, value=True, timeout=180):
try:
adapter = bluezutils.find_adapter()
except (bluezutils.BluezUtilError,
dbus.exceptions.DBusException) as error:
logger.error(str(error) + "\n")
return False
try:
props = dbus.Interface(
self._bus.get_object("org.bluez", adapter.object_path),
"org.freedesktop.DBus.Properties")
timeout = int(timeout)
value = int(value)
if int(props.Get("org.bluez.Adapter1",
"DiscoverableTimeout")) != timeout:
props.Set("org.bluez.Adapter1", "DiscoverableTimeout",
dbus.UInt32(timeout))
if int(props.Get("org.bluez.Adapter1", "Discoverable")) != value:
props.Set("org.bluez.Adapter1", "Discoverable",
dbus.Boolean(value))
except dbus.exceptions.DBusException as error:
logger.error(str(error) + "\n")
return False
logger.info("Discoverable: {}".format(value))
return True
def properties_changed(interface, changed, invalidated, path):
global last_connected_path
global last_connected_time
if interface != "org.bluez.Device1":
return
if changed == None:
return
if changed.has_key('Connected'):
if changed['Connected'] == dbus.Boolean(1):
print(" connecting %s" % path)
last_connected_path = path
save_last_connected_path(path)
last_connected_time = os.times()[4]
set_not_discoverable()
elif changed['Connected'] == dbus.Boolean(0):
print("disconnecting %s" % path)
time = os.times()[4]
if ((last_connected_path == path)
and ((time - last_connected_time) <= DISC_THRES)):
print("Removing this %s" % path)
adapter = bluezutils.find_adapter()
adapter.RemoveDevice(path)
save_last_connected_path("")
audio_play(CONNECTION_ERROR, "")
print("Time is %f - %f = %f %d %d" %
(time, last_connected_time, time - last_connected_time,
path is last_connected_path,
(time - last_connected_time) <= DISC_THRES))
print(" ==%s==" % path)
print(" ==%s==" % last_connected_path)
set_discoverable()
else:
print("PATH: %s PROPS: %s" % (path, changed))
def __init__(self, onBluetoothConnected_callback, onPlayerChanged_callback):
self.onBluetoothConnected_callback = onBluetoothConnected_callback
self.onPlayerChanged_callback = onPlayerChanged_callback
# Get the system bus
try:
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
self.bus = dbus.SystemBus()
except Exception as ex:
print("Unable to get the system dbus: '{0}'. Exiting. Is dbus running?".format(ex.message))
return False
adapter_path = bluezutils.find_adapter(None).object_path
self.adapter = dbus.Interface(self.bus.get_object(bluezutils.SERVICE_NAME, adapter_path), "org.freedesktop.DBus.Properties")
# Power on adapter
self.adapter.Set(bluezutils.ADAPTER_INTERFACE, "Powered", dbus.Boolean(1))
# Set name to display in available connections
self.adapter.Set(bluezutils.ADAPTER_INTERFACE, "Alias", bluezutils.BT_DEVICE_NAME)
# Set pairable on
self.adapter.Set(bluezutils.ADAPTER_INTERFACE, "Pairable", dbus.Boolean(1))
# Set discoverable on
self.adapter.Set(bluezutils.ADAPTER_INTERFACE, "Discoverable", dbus.Boolean(1))
# Set discoverable timeout to 0
self.adapter.Set(bluezutils.ADAPTER_INTERFACE, "DiscoverableTimeout", dbus.UInt32(0))
# Set paraible time out to 0
self.adapter.Set(bluezutils.ADAPTER_INTERFACE, "PairableTimeout", dbus.UInt32(0))
bluezutils.show_adapter_info()
self.path = "/test/agent"
agent = bluezutils.Agent(self.bus, self.path)
obj = self.bus.get_object(bluezutils.SERVICE_NAME, "/org/bluez");
self.manager = dbus.Interface(obj, "org.bluez.AgentManager1")
self.manager.RegisterAgent(self.path, "NoInputNoOutput")
print("Bluetooth AgentManager registered")
# listen for signal of remove adapter
# self.bus.add_signal_receiver(self.interfaces_removed, bus_name=bluezutils.SERVICE_NAME, dbus_interface="org.freedesktop.DBus.ObjectManager", signal_name="InterfacesRemoved")
# listen for signals on the Bluez bus
self.bus.add_signal_receiver(self.device_property_changed, bus_name=bluezutils.SERVICE_NAME, signal_name="PropertiesChanged", path_keyword="device_path", interface_keyword="interface")
# listen for signal of changing properties
self.bus.add_signal_receiver(self.player_changed, bus_name=bluezutils.SERVICE_NAME, dbus_interface="org.freedesktop.DBus.Properties", signal_name="PropertiesChanged", path_keyword="path")
print("Signals receiver registered")
self.manager.RequestDefaultAgent(self.path)
# reconnect automatically to last device
if not self.reconnect():
print("Unable to connect to last device!")
def scan(self, timeout=10):
try:
adapter = bluezutils.find_adapter()
except (bluezutils.BluezUtilError,
dbus.exceptions.DBusException) as error:
logger.error(str(error) + "\n")
else:
try:
adapter.StartDiscovery()
time.sleep(timeout)
adapter.StopDiscovery()
except dbus.exceptions.DBusException as error:
logger.error(str(error) + "\n")
self._scan_thread = None
def remove(self, address):
try:
adapter = bluezutils.find_adapter()
dev = bluezutils.find_device(address)
except (bluezutils.BluezUtilError,
dbus.exceptions.DBusException) as error:
print_error(str(error) + "\n")
return False
try:
adapter.RemoveDevice(dev.object_path)
except dbus.exceptions.DBusException as error:
print_error(str(error) + "\n")
return False
return True
def remove(self, address):
try:
adapter = bluezutils.find_adapter()
dev = bluezutils.find_device(address)
except (bluezutils.BluezUtilError,
dbus.exceptions.DBusException) as error:
logger.error(str(error) + "\n")
return False
try:
adapter.RemoveDevice(dev.object_path)
except dbus.exceptions.DBusException as error:
logger.error(str(error) + "\n")
return False
logger.info("Successfully removed: {}".format(address))
return True
def get_adapter_property(self, prop):
try:
adapter = bluezutils.find_adapter()
except (bluezutils.BluezUtilError,
dbus.exceptions.DBusException) as error:
logger.error(str(error) + "\n")
return None
try:
props = dbus.Interface(
self._bus.get_object("org.bluez", adapter.object_path),
"org.freedesktop.DBus.Properties")
return props.Get("org.bluez.Adapter1", prop)
except dbus.exceptions.DBusException as error:
logger.error(str(error) + "\n")
return None
def find_device_address():
adapter = bluezutils.find_adapter()
adapter_path = adapter.object_path
om = dbus.Interface(bus.get_object("org.bluez", "/"), "org.freedesktop.DBus.ObjectManager")
objects = om.GetManagedObjects()
# find FIRST registered or connected Wii Balance Board ("RVL-WBC-01") and return address
for path, interfaces in objects.iteritems():
if "org.bluez.Device1" not in interfaces:
continue
properties = interfaces["org.bluez.Device1"]
if properties["Adapter"] != adapter_path:
continue
if properties["Alias"] != "Nintendo RVL-WBC-01":
continue
print ("found Wii Balanceboard with address %s" % (properties["Address"]))
return properties["Address"]
def find_device_address():
adapter = bluezutils.find_adapter()
adapter_path = adapter.object_path
om = dbus.Interface(bus.get_object("org.bluez", "/"),
"org.freedesktop.DBus.ObjectManager")
objects = om.GetManagedObjects()
# find FIRST registered or connected Wii Balance Board ("RVL-WBC-01") and return address
for path, interfaces in objects.iteritems():
if "org.bluez.Device1" not in interfaces:
continue
properties = interfaces["org.bluez.Device1"]
if properties["Adapter"] != adapter_path:
continue
if properties["Alias"] != "Nintendo RVL-WBC-01":
continue
print("found Wii Balanceboard with address %s" %
(properties["Address"]))
return properties["Address"]
def set_adapter_property(self, prop, value):
try:
adapter = bluezutils.find_adapter()
except (bluezutils.BluezUtilError,
dbus.exceptions.DBusException) as error:
print_error(str(error) + "\n")
return False
try:
props = dbus.Interface(
self._bus.get_object("org.bluez", adapter.object_path),
"org.freedesktop.DBus.Properties")
if props.Get("org.bluez.Adapter1", prop) != value:
props.Set("org.bluez.Adapter1", prop, value)
except dbus.exceptions.DBusException as error:
print_error(str(error) + "\n")
return False
return True
def make_discoverable(self):
try:
adapter = bluezutils.find_adapter()
except (bluezutils.BluezUtilError,
dbus.exceptions.DBusException) as error:
print_error(str(error) + "\n")
return False
try:
props = dbus.Interface(
self._bus.get_object("org.bluez", adapter.object_path),
"org.freedesktop.DBus.Properties")
if not props.Get("org.bluez.Adapter1", "Discoverable"):
props.Set("org.bluez.Adapter1", "Discoverable",
dbus.Boolean(1))
except dbus.exceptions.DBusException as error:
print_error(str(error) + "\n")
return False
return True
# SPDX-License-Identifier: LGPL-2.1-or-later
import dbus
import bluezutils
bus = dbus.SystemBus()
dummy = dbus.Interface(bus.get_object('org.bluez', '/'),
'org.freedesktop.DBus.Introspectable')
#print dummy.Introspect()
try:
adapter = bluezutils.find_adapter()
except:
pass
LOG.info("Attempting to register Agent with capability '%s' ...",
capability)
Agent(BUS, AGENT_PATH)
obj = BUS.get_object(BUS_NAME, "/org/bluez")
manager = dbus.Interface(obj, "org.bluez.AgentManager1")
manager.RegisterAgent(AGENT_PATH, capability)
manager.RequestDefaultAgent(AGENT_PATH)
LOG.info("Agent registered")
LOG.info("Ensuring that adapter is discoverable/pairable...")
adapter_obj = None
while adapter_obj is None:
try:
adapter_obj = find_adapter().proxy_object
except NoAdapterException as ex:
LOG.warn(
"Can't find BT hardware adapter, retrying in %s seconds...",
RETRY_INTERVAL)
LOG.debug(ex)
time.sleep(RETRY_INTERVAL)
try:
props = dbus.Interface(adapter_obj, "org.freedesktop.DBus.Properties")
props.Set(ADAPTER_INTERFACE, "Discoverable", True)
props.Set(ADAPTER_INTERFACE, "Pairable", True)
props.Set(ADAPTER_INTERFACE, "DiscoverableTimeout", dbus.UInt32(0))
props.Set(ADAPTER_INTERFACE, "PairableTimeout", dbus.UInt32(0))
LOG.info("Adapter is pairable/discoverable now")
try:
from gi.repository import GObject
except ImportError:
import gobject as GObject
bus = dbus.SystemBus()
option_list = [
make_option("-i", "--device", action="store",
type="string", dest="dev_id"),
]
parser = OptionParser(option_list=option_list)
(options, args) = parser.parse_args()
adapter_path = bluezutils.find_adapter(options.dev_id).object_path
server = dbus.Interface(bus.get_object("org.bluez", adapter_path),
"org.bluez.NetworkServer1")
service = "nap"
if (len(args) < 1):
bridge = "tether"
else:
bridge = args[0]
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
mainloop = GObject.MainLoop()
server.Register(service, bridge)
def get_adapter(adapteraddress=None):
return bluezutils.find_adapter(adapteraddress)
def get_adapter_interface(adapteraddress=None):
adapter_path = bluezutils.find_adapter(adapteraddress).object_path
return dbus.Interface(bus.get_object(BLUEZ_OBJECT_PATH, adapter_path),
"org.freedesktop.DBus.Properties")
##################### main
if __name__ == '__main__':
args = parse_cmd_args()
cmd_args = args['cmd_args']
print("cmd_args len",len(args['cmd_args']))
if len(args['cmd_args']) == 0:
print("INVALID: command not specified - supported_commands:")
print_dict_items(g_commands_dict)
exit(-1)
print('cmd_args:',cmd_args)
bus = dbus.SystemBus()
adapter_path = bluezutils.find_adapter(args['a']).object_path
print("adapter_path:",adapter_path)
adapter = dbus.Interface(
bus.get_object("org.bluez", adapter_path),
"org.bluez.Adapter1"
)
print("adapter:",adapter)
# read and work through commands
cmd = args['cmd_args'][0]
if cmd in g_commands_dict:
print("starting command: ", cmd)
globals()['do_'+cmd](adapter, cmd_args)
else:
print("ERROR: command","'"+args['cmd_args'][0]+"'","is not in the supported list - we currently only support: ")
except Exception as e:
print('Characteristic WriteValue() failed: ' + str(e))
raise
char_classes = [
sensor_tag_ir_temperature_char,
sensor_tag_humidity_char,
sensor_tag_barometer_char,
# Can't support the keys without bluez notification support
#sensor_tag_simple_key_service_char,
yeelight_blue_bulb_char,
]
for char_class in char_classes:
known_characteristics[char_class.uuid] = char_class
adapter = bluezutils.find_adapter(bus)
# Connect the D-Bus main loop with the base_lib main loop
base_lib.base_init(adapter.object_path)
def base_run(s, *args):
base_lib.base_run(0)
return True
gobject.io_add_watch(base_lib.s,
gobject.IO_IN | gobject.IO_ERR | gobject.IO_HUP, base_run)
# Make sure adapter is powered on (UP in hciconfig)
adapter_props = dbus.Interface(adapter, 'org.freedesktop.DBus.Properties')
adapter_props.Set(bluezutils.ADAPTER_INTERFACE, 'Powered', dbus.Boolean(True))
# Subscribe to all signals that could indicate a device was just detected
bluezutils.device_listeners.append(device_change)
def start_ble_beaconing():
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
bus = dbus.SystemBus()
option_list = [
make_option("-i", "--device", action="store",
type="string", dest="dev_id"),
make_option("-u", "--uuids", action="store",
type="string", dest="uuids",
help="Filtered service UUIDs [uuid1,uuid2,...]"),
make_option("-r", "--rssi", action="store",
type="int", dest="rssi",
help="RSSI threshold value"),
make_option("-p", "--pathloss", action="store",
type="int", dest="pathloss",
help="Pathloss threshold value"),
make_option("-t", "--transport", action="store",
type="string", dest="transport",
help="Type of scan to run (le/bredr/auto)"),
make_option("-c", "--compact",
action="store_true", dest="compact"),
]
parser = OptionParser(option_list=option_list)
(options, args) = parser.parse_args()
adapter = bluezutils.find_adapter(options.dev_id)
if options.compact:
compact = True;
bus.add_signal_receiver(interfaces_added,
dbus_interface = "org.freedesktop.DBus.ObjectManager",
signal_name = "InterfacesAdded")
bus.add_signal_receiver(properties_changed,
dbus_interface = "org.freedesktop.DBus.Properties",
signal_name = "PropertiesChanged",
arg0 = "org.bluez.Device1",
path_keyword = "path")
om = dbus.Interface(bus.get_object("org.bluez", "/"),
"org.freedesktop.DBus.ObjectManager")
objects = om.GetManagedObjects()
for path, interfaces in objects.iteritems():
if "org.bluez.Device1" in interfaces:
devices[path] = interfaces["org.bluez.Device1"]
scan_filter = dict()
if options.uuids:
uuids = []
uuid_list = options.uuids.split(',')
for uuid in uuid_list:
uuids.append(uuid)
scan_filter.update({ "UUIDs": uuids })
if options.rssi:
scan_filter.update({ "RSSI": dbus.Int16(options.rssi) })
if options.pathloss:
scan_filter.update({ "Pathloss": dbus.UInt16(options.pathloss) })
if options.transport:
scan_filter.update({ "Transport": options.transport })
adapter.SetDiscoveryFilter(scan_filter)
adapter.StartDiscovery()
mainloop = GObject.MainLoop()
mainloop.run()
def get_adapter_interface(adapteraddress=None):
adapter_path = bluezutils.find_adapter(adapteraddress).object_path
return dbus.Interface(bus.get_object(BLUEZ_OBJECT_PATH, adapter_path), "org.freedesktop.DBus.Properties")
def get_adapter(adapteraddress=None):
return bluezutils.find_adapter(adapteraddress)
type="int",
dest="pathloss",
help="Pathloss threshold value"),
make_option("-t",
"--transport",
action="store",
type="string",
dest="transport",
help="Type of scan to run (le/bredr/auto)"),
make_option("-c", "--compact", action="store_true", dest="compact"),
]
parser = OptionParser(option_list=option_list)
(options, args) = parser.parse_args()
adapter = bluezutils.find_adapter(options.dev_id)
if options.compact:
compact = True
bus.add_signal_receiver(
interfaces_added,
dbus_interface="org.freedesktop.DBus.ObjectManager",
signal_name="InterfacesAdded")
bus.add_signal_receiver(properties_changed,
dbus_interface="org.freedesktop.DBus.Properties",
signal_name="PropertiesChanged",
arg0="org.bluez.Device1",
path_keyword="path")
if __name__ == '__main__':
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
bus = dbus.SystemBus()
option_list = [
make_option("-i", "--device", action="store",
type="string", dest="dev_id"),
make_option("-c", "--compact",
action="store_true", dest="compact"),
]
parser = OptionParser(option_list=option_list)
(options, args) = parser.parse_args()
adapter = bluezutils.find_adapter(options.dev_id)
bus.add_signal_receiver(interfaces_added,
dbus_interface = "org.freedesktop.DBus.ObjectManager",
signal_name = "InterfacesAdded")
bus.add_signal_receiver(interfaces_removed,
dbus_interface = "org.freedesktop.DBus.ObjectManager",
signal_name = "InterfacesRemoved")
bus.add_signal_receiver(properties_changed,
dbus_interface = "org.freedesktop.DBus.Properties",
signal_name = "PropertiesChanged",
arg0 = "org.bluez.Device1",
path_keyword = "path")
