static DBusMessage *get_properties(DBusConnection *conn,
DBusMessage *msg, void *data)
{
DBusMessage *reply;
DBusMessageIter iter;
DBusMessageIter dict;
GSList *list;
char **array;
int i;
reply = dbus_message_new_method_return(msg);
if (!reply)
return NULL;
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
array = g_new0(char *, g_slist_length(adapters) + 1);
for (i = 0, list = adapters; list; list = list->next) {
struct btd_adapter *adapter = list->data;
array[i] = (char *) adapter_get_path(adapter);
i++;
}
dict_append_array(&dict, "Adapters", DBUS_TYPE_OBJECT_PATH, &array, i);
g_free(array);
dbus_message_iter_close_container(&iter, &dict);
return reply;
}
void transport_get_properties(struct media_transport *transport,
DBusMessageIter *iter)
{
DBusMessageIter dict;
const char *uuid;
uint8_t codec;
dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
/* Device */
dict_append_entry(&dict, "Device", DBUS_TYPE_OBJECT_PATH,
&transport->device->path);
uuid = media_endpoint_get_uuid(transport->endpoint);
dict_append_entry(&dict, "UUID", DBUS_TYPE_STRING, &uuid);
codec = media_endpoint_get_codec(transport->endpoint);
dict_append_entry(&dict, "Codec", DBUS_TYPE_BYTE, &codec);
dict_append_array(&dict, "Configuration", DBUS_TYPE_BYTE,
&transport->configuration, transport->size);
if (transport->get_properties)
transport->get_properties(transport, &dict);
dbus_message_iter_close_container(iter, &dict);
}
static void append_endpoint(struct media_endpoint *endpoint,
DBusMessageIter *dict)
{
DBusMessageIter entry, var, props;
dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
NULL, &entry);
dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING,
&endpoint->sender);
dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, "a{sv}",
&var);
dbus_message_iter_open_container(&var, DBUS_TYPE_ARRAY,
DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
DBUS_TYPE_STRING_AS_STRING
DBUS_TYPE_VARIANT_AS_STRING
DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
&props);
dict_append_entry(&props, "Path", DBUS_TYPE_OBJECT_PATH,
&endpoint->path);
dict_append_entry(&props, "Codec", DBUS_TYPE_BYTE, &endpoint->codec);
dict_append_array(&props, "Capabilities", DBUS_TYPE_BYTE,
&endpoint->capabilities, endpoint->size);
dbus_message_iter_close_container(&var, &props);
dbus_message_iter_close_container(&entry, &var);
dbus_message_iter_close_container(dict, &entry);
}
static gboolean get_service_data(const GDBusPropertyTable *property,
DBusMessageIter *iter, void *user_data)
{
DBusMessageIter dict;
const uint8_t *data = ad_service_data;
dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, "{sv}", &dict);
dict_append_array(&dict, ad_service_uuid, DBUS_TYPE_BYTE, &data,
ad_service_data_len);
dbus_message_iter_close_container(iter, &dict);
return TRUE;
}
static void update_watcher(gpointer data, gpointer user_data)
{
struct watcher *w = data;
struct measurement *m = user_data;
struct heartrate *hr = m->hr;
const gchar *path = device_get_path(hr->dev);
DBusMessageIter iter;
DBusMessageIter dict;
DBusMessage *msg;
msg = dbus_message_new_method_call(w->srv, w->path,
HEART_RATE_WATCHER_INTERFACE, "MeasurementReceived");
if (msg == NULL)
return;
dbus_message_iter_init_append(msg, &iter);
dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH , &path);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
dict_append_entry(&dict, "Value", DBUS_TYPE_UINT16, &m->value);
if (m->has_energy)
dict_append_entry(&dict, "Energy", DBUS_TYPE_UINT16,
&m->energy);
if (m->has_contact)
dict_append_entry(&dict, "Contact", DBUS_TYPE_BOOLEAN,
&m->contact);
if (m->num_interval > 0)
dict_append_array(&dict, "Interval", DBUS_TYPE_UINT16,
&m->interval, m->num_interval);
dbus_message_iter_close_container(&iter, &dict);
dbus_message_set_no_reply(msg, TRUE);
g_dbus_send_message(btd_get_dbus_connection(), msg);
}
static DBusMessage *prim_get_properties(DBusConnection *conn, DBusMessage *msg,
void *data)
{
struct gatt_service *gatt = data;
DBusMessage *reply;
DBusMessageIter iter;
DBusMessageIter dict;
GSList *l;
char **chars;
const char *uuid;
int i;
reply = dbus_message_new_method_return(msg);
if (!reply)
return NULL;
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
chars = g_new0(char *, g_slist_length(gatt->chars) + 1);
for (i = 0, l = gatt->chars; l; l = l->next, i++) {
struct characteristic *chr = l->data;
chars[i] = chr->path;
}
dict_append_array(&dict, "Characteristics", DBUS_TYPE_OBJECT_PATH,
&chars, i);
uuid = gatt->prim->uuid;
dict_append_entry(&dict, "UUID", DBUS_TYPE_STRING, &uuid);
g_free(chars);
dbus_message_iter_close_container(&iter, &dict);
return reply;
}
static void append_char_dict(DBusMessageIter *iter, struct characteristic *chr)
{
DBusMessageIter dict;
const char *name = "";
char *uuid;
gboolean broadcast;
gboolean indicate;
gboolean notify;
gboolean readable;
char **write_methods;
uint8_t write_methods_count = 0;
dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
uuid = g_strdup(chr->type);
dict_append_entry(&dict, "UUID", DBUS_TYPE_STRING, &uuid);
g_free(uuid);
name = get_char_name(chr->type);
/* FIXME: Translate UUID to name. */
if (name != NULL)
dict_append_entry(&dict, "Name", DBUS_TYPE_STRING, &name);
if (chr->desc)
dict_append_entry(&dict, "Description", DBUS_TYPE_STRING,
&chr->desc);
/* Broadcast */
broadcast = ((chr->perm & GATT_CHAR_PROPS_BROADCAST) != 0) &&
((chr->server_config & GATT_CHAR_SERVERCONF_BROADCAST) != 0);
dict_append_entry(&dict, "Broadcast", DBUS_TYPE_BOOLEAN,
&broadcast);
/* Indicate */
indicate = ((chr->perm & GATT_CHAR_PROPS_INDICATE) != 0) &&
((chr->client_config & GATT_CHAR_CLIENTCONF_INDICATE) != 0);
dict_append_entry(&dict, "Indicate", DBUS_TYPE_BOOLEAN,
&indicate);
/* Notify */
notify = ((chr->perm & GATT_CHAR_PROPS_NOTIFY) != 0) &&
((chr->client_config & GATT_CHAR_CLIENTCONF_NOTIFY) != 0);
dict_append_entry(&dict, "Notify", DBUS_TYPE_BOOLEAN,
¬ify);
/* Readable */
readable = ((chr->perm & GATT_CHAR_PROPS_READ) != 0) ;
dict_append_entry(&dict, "Readable", DBUS_TYPE_BOOLEAN,
&readable);
write_methods = g_new0(char *, 5);
/* WritableNoRsp */
if ((chr->perm & GATT_CHAR_PROPS_WRITE_NO_RSP) != 0)
write_methods[write_methods_count++] = "WriteWithoutResponse";
/* WritableRsp */
if ((chr->perm & GATT_CHAR_PROPS_WRITE) != 0)
write_methods[write_methods_count++] = "Write";
/* WritableAuth */
if ((chr->perm & GATT_CHAR_PROPS_WRITE_AUTHSIGN) != 0)
write_methods[write_methods_count++] = "AuthenticatedSignedWrite";
if ((chr->ext_properties & GATT_CHAR_EXT_PROPS_WRITE_RELIABLE) != 0)
write_methods[write_methods_count++] = "ReliableWrite";
/* TODO : add "WritableAuxiliaries" */
/* TODO : add CustomCharacteristicsDesc */
dict_append_array(&dict, "WriteMethods", DBUS_TYPE_STRING,
&write_methods, write_methods_count);
if (chr->value)
dict_append_array(&dict, "Value", DBUS_TYPE_BYTE, &chr->value,
chr->vlen);
g_free(write_methods);
/* FIXME: Missing Format, Value and Representation */
dbus_message_iter_close_container(iter, &dict);
}
