bluetooth: add UPower backend

UPower provides information about the power supply and battery
level of the host. Add a backend to retrieve the host battery level.

Part-of: <https://gitlab.freedesktop.org/pulseaudio/pulseaudio/-/merge_requests/631>
This commit is contained in:
Dylan Van Assche 2022-04-05 20:26:09 +02:00 committed by PulseAudio Marge Bot
parent cca0d69375
commit 3621731050
3 changed files with 342 additions and 1 deletions

View file

@ -16,6 +16,8 @@ libbluez5_util_headers = [
if get_option('bluez5-native-headset')
libbluez5_util_sources += [ 'backend-native.c' ]
libbluez5_util_sources += [ 'upower.c' ]
libbluez5_util_headers += [ 'upower.h' ]
endif
if get_option('bluez5-ofono-headset')
@ -35,7 +37,7 @@ libbluez5_util = shared_library('bluez5-util',
c_args : [pa_c_args, server_c_args],
link_args : [nodelete_link_args],
include_directories : [configinc, topinc],
dependencies : [libpulse_dep, libpulsecommon_dep, libpulsecore_dep, bluez_dep, dbus_dep, sbc_dep, libintl_dep, bluez5_gst_dep, bluez5_gstapp_dep],
dependencies : [libpulse_dep, libpulsecommon_dep, libpulsecore_dep, bluez_dep, dbus_dep, sbc_dep, libintl_dep, bluez5_gst_dep, bluez5_gstapp_dep, libm_dep],
install : true,
install_rpath : privlibdir,
install_dir : modlibexecdir,

View file

@ -0,0 +1,300 @@
/***
This file is part of PulseAudio.
Copyright 2022 Dylan Van Assche <me@dylanvanassche.be>
PulseAudio is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as
published by the Free Software Foundation; either version 2.1 of the
License, or (at your option) any later version.
PulseAudio is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with PulseAudio; if not, see <http://www.gnu.org/licenses/>.
***/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <math.h>
#include <pulsecore/core-error.h>
#include <pulsecore/core-util.h>
#include <pulsecore/dbus-shared.h>
#include <pulsecore/log.h>
#include <pulse/timeval.h>
#include <pulse/rtclock.h>
#include "upower.h"
static pa_dbus_pending* send_and_add_to_pending(pa_upower_backend *backend, DBusMessage *m,
DBusPendingCallNotifyFunction func, void *call_data) {
pa_dbus_pending *p;
DBusPendingCall *call;
pa_assert(backend);
pa_assert(m);
pa_assert_se(dbus_connection_send_with_reply(pa_dbus_connection_get(backend->connection), m, &call, -1));
p = pa_dbus_pending_new(pa_dbus_connection_get(backend->connection), m, call, backend, call_data);
PA_LLIST_PREPEND(pa_dbus_pending, backend->pending, p);
dbus_pending_call_set_notify(call, func, p, NULL);
return p;
}
static void parse_percentage(pa_upower_backend *b, DBusMessageIter *i) {
double percentage;
unsigned int battery_level;
pa_assert(i);
pa_assert(dbus_message_iter_get_arg_type(i) == DBUS_TYPE_DOUBLE);
dbus_message_iter_get_basic(i, &percentage);
battery_level = (unsigned int) round(percentage / 20.0);
if (battery_level != b->battery_level) {
b->battery_level = battery_level;
pa_log_debug("AG battery level updated (%d/5)", b->battery_level);
pa_hook_fire(pa_bluetooth_discovery_hook(b->discovery, PA_BLUETOOTH_HOOK_HOST_BATTERY_LEVEL_CHANGED), b);
}
}
static void get_percentage_reply(DBusPendingCall *pending, void *userdata) {
pa_dbus_pending *p;
pa_upower_backend *b;
DBusMessage *r;
DBusMessageIter arg_i, variant_i;
pa_assert(pending);
pa_assert_se(p = userdata);
pa_assert_se(b = p->context_data);
pa_assert_se(r = dbus_pending_call_steal_reply(pending));
if (dbus_message_is_error(r, DBUS_ERROR_UNKNOWN_METHOD)) {
pa_log_warn("UPower D-Bus Display Device not available");
goto finish;
}
if (dbus_message_get_type(r) == DBUS_MESSAGE_TYPE_ERROR) {
pa_log_error("Get() failed: %s: %s", dbus_message_get_error_name(r), pa_dbus_get_error_message(r));
goto finish;
}
if (!dbus_message_iter_init(r, &arg_i) || !pa_streq(dbus_message_get_signature(r), "v")) {
pa_log_error("Invalid reply signature for Get()");
goto finish;
}
dbus_message_iter_recurse(&arg_i, &variant_i);
parse_percentage(b, &variant_i);
finish:
dbus_message_unref(r);
PA_LLIST_REMOVE(pa_dbus_pending, b->pending, p);
pa_dbus_pending_free(p);
}
static const char *check_variant_property(DBusMessageIter *i) {
const char *key;
pa_assert(i);
if (dbus_message_iter_get_arg_type(i) != DBUS_TYPE_STRING) {
pa_log_error("Property name not a string.");
return NULL;
}
dbus_message_iter_get_basic(i, &key);
if (!dbus_message_iter_next(i)) {
pa_log_error("Property value missing");
return NULL;
}
if (dbus_message_iter_get_arg_type(i) != DBUS_TYPE_VARIANT) {
pa_log_error("Property value not a variant.");
return NULL;
}
return key;
}
static DBusHandlerResult filter_cb(DBusConnection *bus, DBusMessage *m, void *data) {
DBusError err;
DBusMessage *m2;
static const char* upower_device_interface = UPOWER_SERVICE UPOWER_DEVICE_INTERFACE;
static const char* percentage_property = "Percentage";
pa_upower_backend *b = data;
const char *path, *interface, *member;
pa_assert(bus);
pa_assert(m);
pa_assert(b);
dbus_error_init(&err);
path = dbus_message_get_path(m);
interface = dbus_message_get_interface(m);
member = dbus_message_get_member(m);
pa_log_debug("dbus: path=%s, interface=%s, member=%s", path, interface, member);
/* UPower D-Bus status change */
if (dbus_message_is_signal(m, DBUS_INTERFACE_DBUS, "NameOwnerChanged")) {
const char *name, *old_owner, *new_owner;
if (!dbus_message_get_args(m, &err,
DBUS_TYPE_STRING, &name,
DBUS_TYPE_STRING, &old_owner,
DBUS_TYPE_STRING, &new_owner,
DBUS_TYPE_INVALID)) {
pa_log_error("Failed to parse " DBUS_INTERFACE_DBUS ".NameOwnerChanged: %s", err.message);
goto fail;
}
if (pa_streq(name, UPOWER_SERVICE)) {
/* UPower disappeared from D-Bus */
if (old_owner && *old_owner) {
pa_log_debug("UPower disappeared from D-Bus");
b->battery_level = 0;
pa_hook_fire(pa_bluetooth_discovery_hook(b->discovery, PA_BLUETOOTH_HOOK_HOST_BATTERY_LEVEL_CHANGED), b);
}
/* UPower appeared on D-Bus */
if (new_owner && *new_owner) {
pa_log_debug("UPower appeared on D-Bus");
/* Update battery level */
pa_assert_se(m2 = dbus_message_new_method_call(UPOWER_SERVICE, UPOWER_DISPLAY_DEVICE_OBJECT, DBUS_INTERFACE_PROPERTIES, "Get"));
pa_assert_se(dbus_message_append_args(m2,
DBUS_TYPE_STRING, &upower_device_interface,
DBUS_TYPE_STRING, &percentage_property,
DBUS_TYPE_INVALID));
send_and_add_to_pending(b, m2, get_percentage_reply, NULL);
}
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
/* UPower battery level property updates */
} else if (dbus_message_is_signal(m, DBUS_INTERFACE_PROPERTIES, "PropertiesChanged")) {
DBusMessageIter arg_i, element_i;
if (!dbus_message_iter_init(m, &arg_i) || !pa_streq(dbus_message_get_signature(m), "sa{sv}as")) {
pa_log_error("Invalid signature found in PropertiesChanged");
goto fail;
}
/* Skip interface name */
pa_assert_se(dbus_message_iter_next(&arg_i));
pa_assert(dbus_message_iter_get_arg_type(&arg_i) == DBUS_TYPE_ARRAY);
dbus_message_iter_recurse(&arg_i, &element_i);
/* Parse UPower property updates */
while (dbus_message_iter_get_arg_type(&element_i) == DBUS_TYPE_DICT_ENTRY) {
DBusMessageIter dict_i, variant_i;
const char *key;
dbus_message_iter_recurse(&element_i, &dict_i);
/* Retrieve property name */
key = check_variant_property(&dict_i);
if (key == NULL) {
pa_log_error("Received invalid property!");
break;
}
dbus_message_iter_recurse(&dict_i, &variant_i);
if(pa_streq(path, UPOWER_DISPLAY_DEVICE_OBJECT)) {
pa_log_debug("UPower Device property updated: %s", key);
if(pa_streq(key, "Percentage"))
parse_percentage(b, &variant_i);
}
dbus_message_iter_next(&element_i);
}
}
fail:
dbus_error_free(&err);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
unsigned int pa_upower_get_battery_level(pa_upower_backend *backend) {
return backend->battery_level;
}
pa_upower_backend *pa_upower_backend_new(pa_core *c, pa_bluetooth_discovery *d) {
pa_upower_backend *backend;
DBusError err;
DBusMessage *m;
static const char* upower_device_interface = UPOWER_SERVICE UPOWER_DEVICE_INTERFACE;
static const char* percentage_property = "Percentage";
pa_log_debug("Native backend enabled UPower battery status reporting");
backend = pa_xnew0(pa_upower_backend, 1);
backend->core = c;
backend->discovery = d;
/* Get DBus connection */
dbus_error_init(&err);
if (!(backend->connection = pa_dbus_bus_get(c, DBUS_BUS_SYSTEM, &err))) {
pa_log("Failed to get D-Bus connection: %s", err.message);
dbus_error_free(&err);
pa_xfree(backend);
return NULL;
}
/* Add filter callback for DBus connection */
if (!dbus_connection_add_filter(pa_dbus_connection_get(backend->connection), filter_cb, backend, NULL)) {
pa_log_error("Failed to add filter function");
pa_dbus_connection_unref(backend->connection);
pa_xfree(backend);
return NULL;
}
/* Register for battery level changes from UPower */
if (pa_dbus_add_matches(pa_dbus_connection_get(backend->connection), &err,
"type='signal',sender='" DBUS_SERVICE_DBUS "',interface='" DBUS_INTERFACE_DBUS "',member='NameOwnerChanged',"
"arg0='" UPOWER_SERVICE "'",
"type='signal',sender='" UPOWER_SERVICE "',interface='" DBUS_INTERFACE_PROPERTIES "',member='PropertiesChanged'",
NULL) < 0) {
pa_log("Failed to add UPower D-Bus matches: %s", err.message);
dbus_connection_remove_filter(pa_dbus_connection_get(backend->connection), filter_cb, backend);
pa_dbus_connection_unref(backend->connection);
pa_xfree(backend);
return NULL;
}
/* Initialize battery level by requesting it from UPower */
pa_assert_se(m = dbus_message_new_method_call(UPOWER_SERVICE, UPOWER_DISPLAY_DEVICE_OBJECT, DBUS_INTERFACE_PROPERTIES, "Get"));
pa_assert_se(dbus_message_append_args(m,
DBUS_TYPE_STRING, &upower_device_interface,
DBUS_TYPE_STRING, &percentage_property,
DBUS_TYPE_INVALID));
send_and_add_to_pending(backend, m, get_percentage_reply, NULL);
return backend;
}
void pa_upower_backend_free(pa_upower_backend *backend) {
pa_assert(backend);
pa_dbus_free_pending_list(&backend->pending);
pa_dbus_connection_unref(backend->connection);
pa_xfree(backend);
}

View file

@ -0,0 +1,39 @@
#pragma once
/***
This file is part of PulseAudio.
Copyright 2022 Dylan Van Assche <me@dylanvanassche.be>
PulseAudio is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as
published by the Free Software Foundation; either version 2.1 of the
License, or (at your option) any later version.
PulseAudio is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with PulseAudio; if not, see <http://www.gnu.org/licenses/>.
***/
#include "bluez5-util.h"
#define UPOWER_SERVICE "org.freedesktop.UPower"
#define UPOWER_DEVICE_INTERFACE ".Device"
#define UPOWER_DISPLAY_DEVICE_OBJECT "/org/freedesktop/UPower/devices/DisplayDevice"
struct pa_upower_backend {
pa_core *core;
pa_dbus_connection *connection;
pa_bluetooth_discovery *discovery;
unsigned int battery_level;
PA_LLIST_HEAD(pa_dbus_pending, pending);
};
pa_upower_backend *pa_upower_backend_new(pa_core *c, pa_bluetooth_discovery *d);
void pa_upower_backend_free(pa_upower_backend *backend);
unsigned int pa_upower_get_battery_level(pa_upower_backend *backend);