cras/src/server/cras_bt_battery_provider.c - platform/external/adhd - Git at Google

 /* Copyright 2020 The Chromium OS Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include <dbus/dbus.h>
 #include <errno.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 #include <syslog.h>

 #include "cras_bt_adapter.h"
 #include "cras_bt_battery_provider.h"
 #include "cras_bt_constants.h"
 #include "cras_dbus_util.h"
 #include "cras_observer.h"
 #include "utlist.h"

 /* CRAS registers one battery provider to BlueZ, so we use a singleton. */
 static struct cras_bt_battery_provider battery_provider = {
 	.object_path = CRAS_DEFAULT_BATTERY_PROVIDER,
 	.interface = BLUEZ_INTERFACE_BATTERY_PROVIDER,
 	.conn = NULL,
 	.is_registered = false,
 	.observer = NULL,
 	.batteries = NULL,
 };

 static int cmp_battery_address(const struct cras_bt_battery *battery,
 			       const char *address)
 {
 	return strcmp(battery->address, address);
 }

 static void replace_colon_with_underscore(char *str)
 {
 	for (int i = 0; str[i]; i++) {
 		if (str[i] == ':')
 			str[i] = '_';
 	}
 }

 /* Converts address XX:XX:XX:XX:XX:XX to Battery Provider object path:
  * /org/chromium/Cras/Bluetooth/BatteryProvider/XX_XX_XX_XX_XX_XX
  */
 static char *address_to_battery_path(const char *address)
 {
 	char *object_path = malloc(strlen(CRAS_DEFAULT_BATTERY_PROVIDER) +
 				   strlen(address) + 2);

 	sprintf(object_path, "%s/%s", CRAS_DEFAULT_BATTERY_PROVIDER, address);
 	replace_colon_with_underscore(object_path);

 	return object_path;
 }

 /* Converts address XX:XX:XX:XX:XX:XX to device object path:
  * /org/bluez/hci0/dev_XX_XX_XX_XX_XX_XX
  */
 static char *address_to_device_path(const char *address)
 {
 	char *object_path = malloc(strlen(CRAS_DEFAULT_BATTERY_PREFIX) +
 				   strlen(address) + 1);

 	sprintf(object_path, "%s%s", CRAS_DEFAULT_BATTERY_PREFIX, address);
 	replace_colon_with_underscore(object_path);

 	return object_path;
 }

 static struct cras_bt_battery *battery_new(const char *address, uint32_t level)
 {
 	struct cras_bt_battery *battery;

 	battery = calloc(1, sizeof(struct cras_bt_battery));
 	battery->address = strdup(address);
 	battery->object_path = address_to_battery_path(address);
 	battery->device_path = address_to_device_path(address);
 	battery->level = level;

 	return battery;
 }

 static void battery_free(struct cras_bt_battery *battery)
 {
 	if (battery->address)
 		free(battery->address);
 	if (battery->object_path)
 		free(battery->object_path);
 	if (battery->device_path)
 		free(battery->device_path);
 	free(battery);
 }

 static void populate_battery_properties(DBusMessageIter *iter,
 					const struct cras_bt_battery *battery)
 {
 	DBusMessageIter dict, entry, variant;
 	const char *property_percentage = "Percentage";
 	const char *property_device = "Device";
 	uint8_t level = battery->level;

 	dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, "{sv}", &dict);

 	dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL,
 					 &entry);
 	dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING,
 				       &property_percentage);
 	dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
 					 DBUS_TYPE_BYTE_AS_STRING, &variant);
 	dbus_message_iter_append_basic(&variant, DBUS_TYPE_BYTE, &level);
 	dbus_message_iter_close_container(&entry, &variant);
 	dbus_message_iter_close_container(&dict, &entry);

 	dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL,
 					 &entry);
 	dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING,
 				       &property_device);
 	dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
 					 DBUS_TYPE_OBJECT_PATH_AS_STRING,
 					 &variant);
 	dbus_message_iter_append_basic(&variant, DBUS_TYPE_OBJECT_PATH,
 				       &battery->device_path);
 	dbus_message_iter_close_container(&entry, &variant);
 	dbus_message_iter_close_container(&dict, &entry);

 	dbus_message_iter_close_container(iter, &dict);
 }

 /* Creates a new battery object and exposes it on D-Bus. */
 static struct cras_bt_battery *
 get_or_create_battery(struct cras_bt_battery_provider *provider,
 		      const char *address, uint32_t level)
 {
 	struct cras_bt_battery *battery;
 	DBusMessage *msg;
 	DBusMessageIter iter, dict, entry;

 	LL_SEARCH(provider->batteries, battery, address, cmp_battery_address);

 	if (battery)
 		return battery;

 	syslog(LOG_DEBUG, "Creating new battery for %s", address);

 	battery = battery_new(address, level);
 	LL_APPEND(provider->batteries, battery);

 	msg = dbus_message_new_signal(CRAS_DEFAULT_BATTERY_PROVIDER,
 				      DBUS_INTERFACE_OBJECT_MANAGER,
 				      DBUS_SIGNAL_INTERFACES_ADDED);

 	dbus_message_iter_init_append(msg, &iter);
 	dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH,
 				       &battery->object_path);
 	dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{sa{sv}}",
 					 &dict);
 	dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL,
 					 &entry);
 	dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING,
 				       &provider->interface);
 	populate_battery_properties(&entry, battery);
 	dbus_message_iter_close_container(&dict, &entry);
 	dbus_message_iter_close_container(&iter, &dict);

 	if (!dbus_connection_send(provider->conn, msg, NULL)) {
 		syslog(LOG_ERR,
 		       "Error sending " DBUS_SIGNAL_INTERFACES_ADDED " signal");
 	}

 	dbus_message_unref(msg);

 	return battery;
 }

 /* Updates the level of a battery object and signals it on D-Bus. */
 static void
 update_battery_level(const struct cras_bt_battery_provider *provider,
 		     struct cras_bt_battery *battery, uint32_t level)
 {
 	DBusMessage *msg;
 	DBusMessageIter iter;

 	if (battery->level == level)
 		return;

 	battery->level = level;

 	msg = dbus_message_new_signal(battery->object_path,
 				      DBUS_INTERFACE_PROPERTIES,
 				      DBUS_SIGNAL_PROPERTIES_CHANGED);

 	dbus_message_iter_init_append(msg, &iter);
 	dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING,
 				       &provider->interface);
 	populate_battery_properties(&iter, battery);

 	if (!dbus_connection_send(provider->conn, msg, NULL)) {
 		syslog(LOG_ERR, "Error sending " DBUS_SIGNAL_PROPERTIES_CHANGED
 				" signal");
 	}

 	dbus_message_unref(msg);
 }

 /* Invoked when HFP sends an alert about a battery value change. */
 static void on_bt_battery_changed(void *context, const char *address,
 				  uint32_t level)
 {
 	struct cras_bt_battery_provider *provider = context;

 	syslog(LOG_DEBUG, "Battery changed for address %s, level %d", address,
 	       level);

 	if (!provider->is_registered) {
 		syslog(LOG_WARNING, "Received battery level update while "
 				    "battery provider is not registered");
 		return;
 	}

 	struct cras_bt_battery *battery =
 		get_or_create_battery(provider, address, level);

 	update_battery_level(provider, battery, level);
 }

 /* Invoked when we receive a D-Bus return of RegisterBatteryProvider from
  * BlueZ.
  */
 static void
 cras_bt_on_battery_provider_registered(DBusPendingCall *pending_call,
 				       void *data)
 {
 	DBusMessage *reply;
 	struct cras_bt_battery_provider *provider = data;
 	struct cras_observer_ops observer_ops;

 	reply = dbus_pending_call_steal_reply(pending_call);
 	dbus_pending_call_unref(pending_call);

 	if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
 		syslog(LOG_ERR, "RegisterBatteryProvider returned error: %s",
 		       dbus_message_get_error_name(reply));
 		dbus_message_unref(reply);
 		return;
 	}

 	syslog(LOG_INFO, "RegisterBatteryProvider succeeded");

 	provider->is_registered = true;

 	memset(&observer_ops, 0, sizeof(observer_ops));
 	observer_ops.bt_battery_changed = on_bt_battery_changed;
 	provider->observer = cras_observer_add(&observer_ops, provider);

 	dbus_message_unref(reply);
 }

 int cras_bt_register_battery_provider(DBusConnection *conn,
 				      const struct cras_bt_adapter *adapter)
 {
 	const char *adapter_path;
 	DBusMessage *method_call;
 	DBusMessageIter message_iter;
 	DBusPendingCall *pending_call;

 	if (battery_provider.is_registered) {
 		syslog(LOG_ERR, "Battery Provider already registered");
 		return -EBUSY;
 	}

 	if (battery_provider.conn)
 		dbus_connection_unref(battery_provider.conn);

 	battery_provider.conn = conn;
 	dbus_connection_ref(battery_provider.conn);

 	adapter_path = cras_bt_adapter_object_path(adapter);
 	method_call = dbus_message_new_method_call(
 		BLUEZ_SERVICE, adapter_path,
 		BLUEZ_INTERFACE_BATTERY_PROVIDER_MANAGER,
 		"RegisterBatteryProvider");
 	if (!method_call)
 		return -ENOMEM;

 	dbus_message_iter_init_append(method_call, &message_iter);
 	dbus_message_iter_append_basic(&message_iter, DBUS_TYPE_OBJECT_PATH,
 				       &battery_provider.object_path);

 	if (!dbus_connection_send_with_reply(conn, method_call, &pending_call,
 					     DBUS_TIMEOUT_USE_DEFAULT)) {
 		dbus_message_unref(method_call);
 		return -ENOMEM;
 	}

 	dbus_message_unref(method_call);

 	if (!pending_call)
 		return -EIO;

 	if (!dbus_pending_call_set_notify(
 		    pending_call, cras_bt_on_battery_provider_registered,
 		    &battery_provider, NULL)) {
 		dbus_pending_call_cancel(pending_call);
 		dbus_pending_call_unref(pending_call);
 		return -ENOMEM;
 	}

 	return 0;
 }

 /* Removes a battery object and signals the removal on D-Bus as well. */
 static void cleanup_battery(struct cras_bt_battery_provider *provider,
 			    struct cras_bt_battery *battery)
 {
 	DBusMessage *msg;
 	DBusMessageIter iter, entry;

 	if (!battery)
 		return;

 	LL_DELETE(provider->batteries, battery);

 	msg = dbus_message_new_signal(CRAS_DEFAULT_BATTERY_PROVIDER,
 				      DBUS_INTERFACE_OBJECT_MANAGER,
 				      DBUS_SIGNAL_INTERFACES_REMOVED);

 	dbus_message_iter_init_append(msg, &iter);
 	dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH,
 				       &battery->object_path);
 	dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
 					 DBUS_TYPE_STRING_AS_STRING, &entry);
 	dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING,
 				       &provider->interface);
 	dbus_message_iter_close_container(&iter, &entry);

 	if (!dbus_connection_send(provider->conn, msg, NULL)) {
 		syslog(LOG_ERR, "Error sending " DBUS_SIGNAL_INTERFACES_REMOVED
 				" signal");
 	}

 	dbus_message_unref(msg);

 	battery_free(battery);
 }

 void cras_bt_battery_provider_reset()
 {
 	struct cras_bt_battery *battery;

 	syslog(LOG_INFO, "Resetting battery provider");

 	if (!battery_provider.is_registered)
 		return;

 	battery_provider.is_registered = false;

 	LL_FOREACH (battery_provider.batteries, battery) {
 		cleanup_battery(&battery_provider, battery);
 	}

 	if (battery_provider.conn) {
 		dbus_connection_unref(battery_provider.conn);
 		battery_provider.conn = NULL;
 	}

 	if (battery_provider.observer) {
 		cras_observer_remove(battery_provider.observer);
 		battery_provider.observer = NULL;
 	}
 }
	/* Copyright 2020 The Chromium OS Authors. All rights reserved.
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/
	#include <dbus/dbus.h>
	#include <errno.h>
	#include <stdint.h>
	#include <stdlib.h>
	#include <string.h>
	#include <syslog.h>

	#include "cras_bt_adapter.h"
	#include "cras_bt_battery_provider.h"
	#include "cras_bt_constants.h"
	#include "cras_dbus_util.h"
	#include "cras_observer.h"
	#include "utlist.h"

	/* CRAS registers one battery provider to BlueZ, so we use a singleton. */
	static struct cras_bt_battery_provider battery_provider = {
	.object_path = CRAS_DEFAULT_BATTERY_PROVIDER,
	.interface = BLUEZ_INTERFACE_BATTERY_PROVIDER,
	.conn = NULL,
	.is_registered = false,
	.observer = NULL,
	.batteries = NULL,
	};

	static int cmp_battery_address(const struct cras_bt_battery *battery,
	const char *address)
	{
	return strcmp(battery->address, address);
	}

	static void replace_colon_with_underscore(char *str)
	{
	for (int i = 0; str[i]; i++) {
	if (str[i] == ':')
	str[i] = '_';
	}
	}

	/* Converts address XX:XX:XX:XX:XX:XX to Battery Provider object path:
	* /org/chromium/Cras/Bluetooth/BatteryProvider/XX_XX_XX_XX_XX_XX
	*/
	static char address_to_battery_path(const char address)
	{
	char *object_path = malloc(strlen(CRAS_DEFAULT_BATTERY_PROVIDER) +
	strlen(address) + 2);

	sprintf(object_path, "%s/%s", CRAS_DEFAULT_BATTERY_PROVIDER, address);
	replace_colon_with_underscore(object_path);

	return object_path;
	}

	/* Converts address XX:XX:XX:XX:XX:XX to device object path:
	* /org/bluez/hci0/dev_XX_XX_XX_XX_XX_XX
	*/
	static char address_to_device_path(const char address)
	{
	char *object_path = malloc(strlen(CRAS_DEFAULT_BATTERY_PREFIX) +
	strlen(address) + 1);

	sprintf(object_path, "%s%s", CRAS_DEFAULT_BATTERY_PREFIX, address);
	replace_colon_with_underscore(object_path);

	return object_path;
	}

	static struct cras_bt_battery battery_new(const char address, uint32_t level)
	{
	struct cras_bt_battery *battery;

	battery = calloc(1, sizeof(struct cras_bt_battery));
	battery->address = strdup(address);
	battery->object_path = address_to_battery_path(address);
	battery->device_path = address_to_device_path(address);
	battery->level = level;

	return battery;
	}

	static void battery_free(struct cras_bt_battery *battery)
	{
	if (battery->address)
	free(battery->address);
	if (battery->object_path)
	free(battery->object_path);
	if (battery->device_path)
	free(battery->device_path);
	free(battery);
	}

	static void populate_battery_properties(DBusMessageIter *iter,
	const struct cras_bt_battery *battery)
	{
	DBusMessageIter dict, entry, variant;
	const char *property_percentage = "Percentage";
	const char *property_device = "Device";
	uint8_t level = battery->level;

	dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, "{sv}", &dict);

	dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL,
	&entry);
	dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING,
	&property_percentage);
	dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
	DBUS_TYPE_BYTE_AS_STRING, &variant);
	dbus_message_iter_append_basic(&variant, DBUS_TYPE_BYTE, &level);
	dbus_message_iter_close_container(&entry, &variant);
	dbus_message_iter_close_container(&dict, &entry);

	dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL,
	&entry);
	dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING,
	&property_device);
	dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
	DBUS_TYPE_OBJECT_PATH_AS_STRING,
	&variant);
	dbus_message_iter_append_basic(&variant, DBUS_TYPE_OBJECT_PATH,
	&battery->device_path);
	dbus_message_iter_close_container(&entry, &variant);
	dbus_message_iter_close_container(&dict, &entry);

	dbus_message_iter_close_container(iter, &dict);
	}

	/* Creates a new battery object and exposes it on D-Bus. */
	static struct cras_bt_battery *
	get_or_create_battery(struct cras_bt_battery_provider *provider,
	const char *address, uint32_t level)
	{
	struct cras_bt_battery *battery;
	DBusMessage *msg;
	DBusMessageIter iter, dict, entry;

	LL_SEARCH(provider->batteries, battery, address, cmp_battery_address);

	if (battery)
	return battery;

	syslog(LOG_DEBUG, "Creating new battery for %s", address);

	battery = battery_new(address, level);
	LL_APPEND(provider->batteries, battery);

	msg = dbus_message_new_signal(CRAS_DEFAULT_BATTERY_PROVIDER,
	DBUS_INTERFACE_OBJECT_MANAGER,
	DBUS_SIGNAL_INTERFACES_ADDED);

	dbus_message_iter_init_append(msg, &iter);
	dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH,
	&battery->object_path);
	dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{sa{sv}}",
	&dict);
	dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL,
	&entry);
	dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING,
	&provider->interface);
	populate_battery_properties(&entry, battery);
	dbus_message_iter_close_container(&dict, &entry);
	dbus_message_iter_close_container(&iter, &dict);

	if (!dbus_connection_send(provider->conn, msg, NULL)) {
	syslog(LOG_ERR,
	"Error sending " DBUS_SIGNAL_INTERFACES_ADDED " signal");
	}

	dbus_message_unref(msg);

	return battery;
	}

	/* Updates the level of a battery object and signals it on D-Bus. */
	static void
	update_battery_level(const struct cras_bt_battery_provider *provider,
	struct cras_bt_battery *battery, uint32_t level)
	{
	DBusMessage *msg;
	DBusMessageIter iter;

	if (battery->level == level)
	return;

	battery->level = level;

	msg = dbus_message_new_signal(battery->object_path,
	DBUS_INTERFACE_PROPERTIES,
	DBUS_SIGNAL_PROPERTIES_CHANGED);

	dbus_message_iter_init_append(msg, &iter);
	dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING,
	&provider->interface);
	populate_battery_properties(&iter, battery);

	if (!dbus_connection_send(provider->conn, msg, NULL)) {
	syslog(LOG_ERR, "Error sending " DBUS_SIGNAL_PROPERTIES_CHANGED
	" signal");
	}

	dbus_message_unref(msg);
	}

	/* Invoked when HFP sends an alert about a battery value change. */
	static void on_bt_battery_changed(void context, const char address,
	uint32_t level)
	{
	struct cras_bt_battery_provider *provider = context;

	syslog(LOG_DEBUG, "Battery changed for address %s, level %d", address,
	level);

	if (!provider->is_registered) {
	syslog(LOG_WARNING, "Received battery level update while "
	"battery provider is not registered");
	return;
	}

	struct cras_bt_battery *battery =
	get_or_create_battery(provider, address, level);

	update_battery_level(provider, battery, level);
	}

	/* Invoked when we receive a D-Bus return of RegisterBatteryProvider from
	* BlueZ.
	*/
	static void
	cras_bt_on_battery_provider_registered(DBusPendingCall *pending_call,
	void *data)
	{
	DBusMessage *reply;
	struct cras_bt_battery_provider *provider = data;
	struct cras_observer_ops observer_ops;

	reply = dbus_pending_call_steal_reply(pending_call);
	dbus_pending_call_unref(pending_call);

	if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
	syslog(LOG_ERR, "RegisterBatteryProvider returned error: %s",
	dbus_message_get_error_name(reply));
	dbus_message_unref(reply);
	return;
	}

	syslog(LOG_INFO, "RegisterBatteryProvider succeeded");

	provider->is_registered = true;

	memset(&observer_ops, 0, sizeof(observer_ops));
	observer_ops.bt_battery_changed = on_bt_battery_changed;
	provider->observer = cras_observer_add(&observer_ops, provider);

	dbus_message_unref(reply);
	}

	int cras_bt_register_battery_provider(DBusConnection *conn,
	const struct cras_bt_adapter *adapter)
	{
	const char *adapter_path;
	DBusMessage *method_call;
	DBusMessageIter message_iter;
	DBusPendingCall *pending_call;

	if (battery_provider.is_registered) {
	syslog(LOG_ERR, "Battery Provider already registered");
	return -EBUSY;
	}

	if (battery_provider.conn)
	dbus_connection_unref(battery_provider.conn);

	battery_provider.conn = conn;
	dbus_connection_ref(battery_provider.conn);

	adapter_path = cras_bt_adapter_object_path(adapter);
	method_call = dbus_message_new_method_call(
	BLUEZ_SERVICE, adapter_path,
	BLUEZ_INTERFACE_BATTERY_PROVIDER_MANAGER,
	"RegisterBatteryProvider");
	if (!method_call)
	return -ENOMEM;

	dbus_message_iter_init_append(method_call, &message_iter);
	dbus_message_iter_append_basic(&message_iter, DBUS_TYPE_OBJECT_PATH,
	&battery_provider.object_path);

	if (!dbus_connection_send_with_reply(conn, method_call, &pending_call,
	DBUS_TIMEOUT_USE_DEFAULT)) {
	dbus_message_unref(method_call);
	return -ENOMEM;
	}

	dbus_message_unref(method_call);

	if (!pending_call)
	return -EIO;

	if (!dbus_pending_call_set_notify(
	pending_call, cras_bt_on_battery_provider_registered,
	&battery_provider, NULL)) {
	dbus_pending_call_cancel(pending_call);
	dbus_pending_call_unref(pending_call);
	return -ENOMEM;
	}

	return 0;
	}

	/* Removes a battery object and signals the removal on D-Bus as well. */
	static void cleanup_battery(struct cras_bt_battery_provider *provider,
	struct cras_bt_battery *battery)
	{
	DBusMessage *msg;
	DBusMessageIter iter, entry;

	if (!battery)
	return;

	LL_DELETE(provider->batteries, battery);

	msg = dbus_message_new_signal(CRAS_DEFAULT_BATTERY_PROVIDER,
	DBUS_INTERFACE_OBJECT_MANAGER,
	DBUS_SIGNAL_INTERFACES_REMOVED);

	dbus_message_iter_init_append(msg, &iter);
	dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH,
	&battery->object_path);
	dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
	DBUS_TYPE_STRING_AS_STRING, &entry);
	dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING,
	&provider->interface);
	dbus_message_iter_close_container(&iter, &entry);

	if (!dbus_connection_send(provider->conn, msg, NULL)) {
	syslog(LOG_ERR, "Error sending " DBUS_SIGNAL_INTERFACES_REMOVED
	" signal");
	}

	dbus_message_unref(msg);

	battery_free(battery);
	}

	void cras_bt_battery_provider_reset()
	{
	struct cras_bt_battery *battery;

	syslog(LOG_INFO, "Resetting battery provider");

	if (!battery_provider.is_registered)
	return;

	battery_provider.is_registered = false;

	LL_FOREACH (battery_provider.batteries, battery) {
	cleanup_battery(&battery_provider, battery);
	}

	if (battery_provider.conn) {
	dbus_connection_unref(battery_provider.conn);
	battery_provider.conn = NULL;
	}

	if (battery_provider.observer) {
	cras_observer_remove(battery_provider.observer);
	battery_provider.observer = NULL;
	}
	}