[PATCH 1/2 v3] plugins: add upower battery monitor for bluetooth

[Tony Espy <espy@canonical.com>]

[-- Attachment #1: Type: text/plain, Size: 10461 bytes --]

---
 plugins/upower.c | 388 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 388 insertions(+)
 create mode 100644 plugins/upower.c

diff --git a/plugins/upower.c b/plugins/upower.c
new file mode 100644
index 0000000..5500f00
--- /dev/null
+++ b/plugins/upower.c
@@ -0,0 +1,388 @@
+/*
+ *
+ *  oFono - Open Source Telephony
+ *
+ *  Copyright (C) 2015 Canonical Ltd.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ *
+ *  This program 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 General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <glib.h>
+#include <gdbus.h>
+#include <ofono.h>
+
+#define OFONO_API_SUBJECT_TO_CHANGE
+#include <ofono/plugin.h>
+#include <ofono/modem.h>
+#include <ofono/log.h>
+#include <ofono/emulator.h>
+
+#define DBUS_PROPERTIES_INTERFACE     "org.freedesktop.DBus.Properties"
+#define UPOWER_SERVICE                "org.freedesktop.UPower"
+#define UPOWER_PATH                   "/org/freedesktop/UPower"
+#define UPOWER_INTERFACE              UPOWER_SERVICE
+#define UPOWER_DEVICE_INTERFACE       UPOWER_SERVICE ".Device"
+
+static guint modem_watch;
+static guint upower_daemon_watch;
+static DBusConnection *connection;
+static GHashTable *modem_hfp_watches;
+static int last_battery_level;
+static char *battery_device_path;
+
+static void emulator_battery_cb(struct ofono_atom *atom, void *data)
+{
+	struct ofono_emulator *em = __ofono_atom_get_data(atom);
+	int val = GPOINTER_TO_INT(data);
+
+	DBG("calling set_indicator: %d", val);
+	ofono_emulator_set_indicator(em, OFONO_EMULATOR_IND_BATTERY, val);
+}
+
+static void update_modem_battery_indicator(struct ofono_modem *modem,
+								void *data)
+{
+	__ofono_modem_foreach_registered_atom(modem,
+				OFONO_ATOM_TYPE_EMULATOR_HFP,
+				emulator_battery_cb,
+				data);
+}
+
+static void update_battery_level(double percentage_val)
+{
+	int battery_level;
+
+	if (percentage_val <= 1.00) {
+		battery_level = 0;
+	} else if (percentage_val > 1.00 && percentage_val <= 100.00) {
+		battery_level = ((int) percentage_val - 1) / 20 + 1;
+	} else {
+		ofono_error("%s: Invalid value for battery level: %f",
+								__func__,
+								percentage_val);
+		return;
+	}
+
+	DBG("last_battery_level: %d battery_level: %d (%f)", last_battery_level,
+						battery_level, percentage_val);
+
+	if (last_battery_level == battery_level)
+		return;
+
+	last_battery_level = battery_level;
+
+	__ofono_modem_foreach(update_modem_battery_indicator,
+					GINT_TO_POINTER(battery_level));
+}
+
+static gboolean battery_props_changed(DBusConnection *conn, DBusMessage *msg,
+				void *user_data)
+
+{
+	const char *iface;
+	DBusMessageIter iter, dict;
+	double percentage_val;
+	gboolean percentage_found = FALSE;
+	gboolean retval = FALSE;
+
+	DBG("");
+
+	dbus_message_iter_init(msg, &iter);
+
+	if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) {
+		ofono_error("%s: iface != TYPE_STRING!", __func__);
+		goto done;
+	}
+
+	dbus_message_iter_get_basic(&iter, &iface);
+
+	if (g_str_equal(iface, UPOWER_DEVICE_INTERFACE) != TRUE) {
+		ofono_error("%s: wrong iface: %s!", __func__, iface);
+		goto done;
+	}
+
+	if (!dbus_message_iter_next(&iter)) {
+		ofono_error("%s: advance iter failed!", __func__);
+		goto done;
+	}
+
+	if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) {
+		ofono_error("%s: type != ARRAY!", __func__);
+		goto done;
+	}
+
+	dbus_message_iter_recurse(&iter, &dict);
+
+	while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+		DBusMessageIter entry, val;
+		const char *key;
+
+		dbus_message_iter_recurse(&dict, &entry);
+
+		if (dbus_message_iter_get_arg_type(&entry) !=
+				DBUS_TYPE_STRING) {
+			ofono_error("%s: key type != STRING!", __func__);
+			goto done;
+		}
+
+		dbus_message_iter_get_basic(&entry, &key);
+
+		if (g_str_equal(key, "Percentage") != TRUE) {
+			dbus_message_iter_next(&dict);
+			continue;
+		}
+
+		dbus_message_iter_next(&entry);
+		if (dbus_message_iter_get_arg_type(&entry) !=
+				DBUS_TYPE_VARIANT) {
+			ofono_error("%s: 'Percentage' val != VARIANT",
+								__func__);
+			goto done;
+		}
+
+		dbus_message_iter_recurse(&entry, &val);
+
+		if (dbus_message_iter_get_arg_type(&val) != DBUS_TYPE_DOUBLE) {
+			ofono_error("%s: 'Percentage' val != DOUBLE", __func__);
+			goto done;
+		}
+
+		dbus_message_iter_get_basic(&val, &percentage_val);
+		percentage_found = TRUE;
+		break;
+	}
+
+	/* No errors found during parsing, so don't trigger cb removal */
+	retval = TRUE;
+
+	if (percentage_found == FALSE)
+		goto done;
+
+	update_battery_level(percentage_val);
+
+done:
+	return retval;
+}
+
+static void emulator_hfp_watch(struct ofono_atom *atom,
+				enum ofono_atom_watch_condition cond,
+				void *data)
+{
+	if (cond == OFONO_ATOM_WATCH_CONDITION_REGISTERED) {
+		struct ofono_emulator *em = __ofono_atom_get_data(atom);
+
+		DBG("REGISTERED; calling set_indicator: %d", last_battery_level);
+
+		ofono_emulator_set_indicator(em, OFONO_EMULATOR_IND_BATTERY,
+							last_battery_level);
+		return;
+	}
+
+	DBG("UNREGISTERED");
+}
+
+static void modemwatch(struct ofono_modem *modem, gboolean added, void *user)
+{
+
+	const char *path = ofono_modem_get_path(modem);
+
+	DBG("modem: %s, added: %d", path, added);
+
+	if (added) {
+		guint watch_id;
+
+		watch_id = __ofono_modem_add_atom_watch(modem,
+					OFONO_ATOM_TYPE_EMULATOR_HFP,
+					emulator_hfp_watch, NULL, NULL);
+
+		g_hash_table_insert(modem_hfp_watches, g_strdup(path),
+						GINT_TO_POINTER(watch_id));
+
+	} else {
+		guint *watch_id = g_hash_table_lookup(modem_hfp_watches, path);
+
+		if (watch_id != NULL) {
+			__ofono_modem_remove_atom_watch(modem, *watch_id);
+			g_hash_table_remove(modem_hfp_watches, path);
+		}
+	}
+}
+
+static void call_modemwatch(struct ofono_modem *modem, void *user)
+{
+	modemwatch(modem, TRUE, user);
+}
+
+static gboolean parse_devices_reply(DBusMessage *reply)
+{
+	DBusMessageIter array, iter;
+	const char *path;
+
+	DBG("");
+
+	if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
+		ofono_error("%s: ERROR reply to EnumerateDevices", __func__);
+		return FALSE;
+	}
+
+	if (dbus_message_iter_init(reply, &array) == FALSE) {
+		ofono_error("%s: error initializing array iter", __func__);
+		return FALSE;
+	}
+
+	if (dbus_message_iter_get_arg_type(&array) != DBUS_TYPE_ARRAY) {
+		ofono_error("%s: type != ARRAY!", __func__);
+		return FALSE;
+	}
+
+	dbus_message_iter_recurse(&array, &iter);
+
+	while (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_OBJECT_PATH) {
+
+		dbus_message_iter_get_basic(&iter, &path);
+
+		if (g_strrstr(path, "/battery_")) {
+			ofono_info("%s: found 1st battery device: %s", __func__,
+									path);
+			battery_device_path = g_strdup(path);
+			break;
+		}
+
+		if (!dbus_message_iter_next(&iter))
+			break;
+	}
+
+	return TRUE;
+}
+
+static void enum_devices_reply(DBusPendingCall *call, void *user_data)
+{
+	DBusMessage *reply;
+
+	DBG("");
+
+	reply = dbus_pending_call_steal_reply(call);
+	if (reply == NULL) {
+		ofono_error("%s: dbus_message_new_method failed", __func__);
+		goto done;
+	}
+
+	if (parse_devices_reply(reply) == FALSE)
+		goto done;
+
+	DBG("parse_devices_reply OK");
+
+	/* TODO: handle removable batteries */
+
+	if (battery_device_path == NULL) {
+		ofono_error("%s: no battery detected", __func__);
+		goto done;
+	}
+
+	/* Always listen to PropertiesChanged for battery */
+	g_dbus_add_signal_watch(connection, UPOWER_SERVICE, battery_device_path,
+						DBUS_INTERFACE_PROPERTIES,
+						"PropertiesChanged",
+						battery_props_changed,
+						NULL, NULL);
+
+	modem_watch = __ofono_modemwatch_add(modemwatch, NULL, NULL);
+	__ofono_modem_foreach(call_modemwatch, NULL);
+
+done:
+	if (reply)
+		dbus_message_unref(reply);
+
+	dbus_pending_call_unref(call);
+}
+
+static void upower_connect(DBusConnection *conn, void *user_data)
+{
+	DBusPendingCall *call;
+	DBusMessage *msg;
+
+	DBG("upower connect");
+
+	msg = dbus_message_new_method_call(UPOWER_SERVICE,
+						UPOWER_PATH,
+						UPOWER_INTERFACE,
+						"EnumerateDevices");
+	if (msg == NULL) {
+		ofono_error("%s: dbus_message_new_method failed", __func__);
+		return;
+	}
+
+	if (!dbus_connection_send_with_reply(conn, msg, &call, -1)) {
+		ofono_error("%s: Sending EnumerateDevices failed", __func__);
+		goto done;
+	}
+
+	dbus_pending_call_set_notify(call, enum_devices_reply, NULL, NULL);
+done:
+	dbus_message_unref(msg);
+}
+
+static void upower_disconnect(DBusConnection *conn, void *user_data)
+{
+	DBG("upower disconnect");
+
+	if (modem_watch) {
+		__ofono_modemwatch_remove(modem_watch);
+		modem_watch = 0;
+	}
+
+	if (battery_device_path) {
+		g_free(battery_device_path);
+		battery_device_path = NULL;
+	}
+}
+
+static int upower_init(void)
+{
+	DBG("upower init");
+
+	connection = ofono_dbus_get_connection();
+	upower_daemon_watch = g_dbus_add_service_watch(connection,
+							UPOWER_SERVICE,
+							upower_connect,
+							upower_disconnect,
+							NULL, NULL);
+
+	modem_hfp_watches = g_hash_table_new_full(g_str_hash, g_str_equal,
+				g_free, NULL);
+
+	return 0;
+}
+
+static void upower_exit(void)
+{
+	if (upower_daemon_watch)
+		g_dbus_remove_watch(connection, upower_daemon_watch);
+
+	if (modem_watch)
+		__ofono_modemwatch_remove(modem_watch);
+
+	if (battery_device_path)
+		g_free(battery_device_path);
+
+	g_hash_table_destroy(modem_hfp_watches);
+}
+
+OFONO_PLUGIN_DEFINE(upower, "upower battery monitor", VERSION,
+		OFONO_PLUGIN_PRIORITY_DEFAULT, upower_init, upower_exit)
-- 
2.1.4