static DBusMessage *input_device_get_properties(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct input_device *idev = data;
DBusMessage *reply;
DBusMessageIter iter;
DBusMessageIter dict;
dbus_bool_t connected;
const char *reconnect_mode = NULL;
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);
/* Connected */
connected = !!g_slist_find_custom(idev->connections, NULL,
(GCompareFunc) connected_cmp);
dict_append_entry(&dict, "Connected", DBUS_TYPE_BOOLEAN, &connected);
/* Reconnection mode */
reconnect_mode = reconnect_mode_to_string(idev->reconnect_mode);
dict_append_entry(&dict, "ReconnectMode", DBUS_TYPE_STRING,
&reconnect_mode);
dbus_message_iter_close_container(&iter, &dict);
return reply;
}
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);
}
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 DBusMessage *get_properties(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct monitor *monitor = data;
DBusMessageIter iter;
DBusMessageIter dict;
DBusMessage *reply;
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);
if (monitor->enabled.linkloss)
dict_append_entry(&dict, "LinkLossAlertLevel",
DBUS_TYPE_STRING, &monitor->linklosslevel);
if (monitor->enabled.findme || monitor->enabled.pathloss)
dict_append_entry(&dict, "ImmediateAlertLevel",
DBUS_TYPE_STRING, &monitor->immediatelevel);
if (monitor->enabled.pathloss)
dict_append_entry(&dict, "SignalLevel",
DBUS_TYPE_STRING, &monitor->signallevel);
dbus_message_iter_close_container(&iter, &dict);
return reply;
}
static void get_properties_a2dp(struct media_transport *transport,
DBusMessageIter *dict)
{
struct a2dp_transport *a2dp = transport->data;
dict_append_entry(dict, "Delay", DBUS_TYPE_UINT16, &a2dp->delay);
if (a2dp->volume <= 127)
dict_append_entry(dict, "Volume", DBUS_TYPE_UINT16,
&a2dp->volume);
}
static DBusMessage *connection_get_properties(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct network_peer *peer = data;
struct network_conn *nc = NULL;
DBusMessage *reply;
DBusMessageIter iter;
DBusMessageIter dict;
dbus_bool_t connected;
const char *property;
GSList *l;
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);
/* Connected */
for (l = peer->connections; l; l = l->next) {
struct network_conn *tmp = l->data;
if (tmp->state != CONNECTED)
continue;
nc = tmp;
break;
}
connected = nc ? TRUE : FALSE;
dict_append_entry(&dict, "Connected", DBUS_TYPE_BOOLEAN, &connected);
/* Interface */
property = nc ? nc->dev : "";
dict_append_entry(&dict, "Interface", DBUS_TYPE_STRING, &property);
/* UUID */
property = nc ? bnep_uuid(nc->id) : "";
dict_append_entry(&dict, "UUID", DBUS_TYPE_STRING, &property);
dbus_message_iter_close_container(&iter, &dict);
return reply;
}
static void get_properties_headset(struct media_transport *transport,
DBusMessageIter *dict)
{
gboolean nrec, inband;
const char *routing;
nrec = headset_get_nrec(transport->device);
dict_append_entry(dict, "NREC", DBUS_TYPE_BOOLEAN, &nrec);
inband = headset_get_inband(transport->device);
dict_append_entry(dict, "InbandRingtone", DBUS_TYPE_BOOLEAN, &inband);
routing = headset_get_sco_hci(transport->device) ? "HCI" : "PCM";
dict_append_entry(dict, "Routing", DBUS_TYPE_STRING, &routing);
}
static DBusMessage *control_get_properties(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct audio_device *device = data;
DBusMessage *reply;
DBusMessageIter iter;
DBusMessageIter dict;
gboolean value;
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);
/* Connected */
value = (device->control->session != NULL);
dict_append_entry(&dict, "Connected", DBUS_TYPE_BOOLEAN, &value);
dbus_message_iter_close_container(&iter, &dict);
return reply;
}
static void append_track(void *key, void *value, void *user_data)
{
DBusMessageIter *dict = user_data;
const char *strkey = key;
if (strcasecmp(strkey, "Duration") == 0 ||
strcasecmp(strkey, "TrackNumber") == 0 ||
strcasecmp(strkey, "NumberOfTracks") == 0) {
uint32_t num = atoi(value);
dict_append_entry(dict, key, DBUS_TYPE_UINT32, &num);
} else if (strcasecmp(strkey, "Item") == 0) {
dict_append_entry(dict, key, DBUS_TYPE_OBJECT_PATH, &value);
} else {
dict_append_entry(dict, key, DBUS_TYPE_STRING, &value);
}
}
static DBusMessage *get_properties(DBusConnection *c,
DBusMessage *msg, void *data)
{
struct sap_connection *conn = data;
DBusMessage *reply;
DBusMessageIter iter;
DBusMessageIter dict;
dbus_bool_t connected;
if (!conn)
return message_failed(msg, "Server internal error.");
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);
connected = (conn->state == SAP_STATE_CONNECTED ||
conn->state == SAP_STATE_GRACEFUL_DISCONNECT);
dict_append_entry(&dict, "Connected", DBUS_TYPE_BOOLEAN, &connected);
dbus_message_iter_close_container(&iter, &dict);
return reply;
}
static DBusMessage *dev_get_properties(DBusConnection *conn, DBusMessage *msg,
void *data)
{
struct audio_device *device = data;
DBusMessage *reply;
DBusMessageIter iter;
DBusMessageIter dict;
const char *state;
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);
/* State */
state = state2str(device->priv->state);
if (state)
dict_append_entry(&dict, "State", DBUS_TYPE_STRING, &state);
dbus_message_iter_close_container(&iter, &dict);
return reply;
}
static void update_watcher(gpointer data, gpointer user_data)
{
struct watcher *w = data;
struct measurement *m = user_data;
struct csc *csc = m->csc;
const char *path = device_get_path(csc->dev);
DBusMessageIter iter;
DBusMessageIter dict;
DBusMessage *msg;
msg = dbus_message_new_method_call(w->srv, w->path,
CYCLINGSPEED_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);
if (m->has_wheel_rev) {
dict_append_entry(&dict, "WheelRevolutions",
DBUS_TYPE_UINT32, &m->wheel_rev);
dict_append_entry(&dict, "LastWheelEventTime",
DBUS_TYPE_UINT16, &m->last_wheel_time);
}
if (m->has_crank_rev) {
dict_append_entry(&dict, "CrankRevolutions",
DBUS_TYPE_UINT16, &m->crank_rev);
dict_append_entry(&dict, "LastCrankEventTime",
DBUS_TYPE_UINT16, &m->last_crank_time);
}
dbus_message_iter_close_container(&iter, &dict);
dbus_message_set_no_reply(msg, TRUE);
g_dbus_send_message(btd_get_dbus_connection(), msg);
}
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 *sink_get_properties(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct audio_device *device = data;
struct sink *sink = device->sink;
DBusMessage *reply;
DBusMessageIter iter;
DBusMessageIter dict;
const char *state;
gboolean value;
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);
/* Playing */
value = (sink->stream_state == AVDTP_STATE_STREAMING);
dict_append_entry(&dict, "Playing", DBUS_TYPE_BOOLEAN, &value);
/* Connected */
value = (sink->stream_state >= AVDTP_STATE_CONFIGURED);
dict_append_entry(&dict, "Connected", DBUS_TYPE_BOOLEAN, &value);
/* State */
state = state2str(sink->state);
if (state)
dict_append_entry(&dict, "State", DBUS_TYPE_STRING, &state);
dbus_message_iter_close_container(&iter, &dict);
return reply;
}
static DBusMessage *get_properties(DBusConnection *conn,
DBusMessage *msg, void *data)
{
DBusMessageIter iter;
DBusMessageIter dict;
DBusMessage *reply = NULL;
const char *linkloss_level, *immalert_level;
struct btd_device *device = data;
reply = dbus_message_new_method_return(msg);
if (!reply)
return NULL;
linkloss_level = link_loss_get_alert_level(device);
immalert_level = imm_alert_get_level(device);
dbus_message_iter_init_append(reply, &iter);
if (!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))
goto err;
dict_append_entry(&dict, "LinkLossAlertLevel", DBUS_TYPE_STRING,
&linkloss_level);
dict_append_entry(&dict, "ImmediateAlertLevel", DBUS_TYPE_STRING,
&immalert_level);
if (!dbus_message_iter_close_container(&iter, &dict))
goto err;
return reply;
err:
if (reply)
dbus_message_unref(reply);
return btd_error_failed(msg, "not enough memory");
}
static DBusMessage *get_properties(DBusConnection *conn, DBusMessage *msg,
void *data)
{
struct heartrate *hr = data;
DBusMessageIter iter;
DBusMessageIter dict;
DBusMessage *reply;
gboolean has_reset;
reply = dbus_message_new_method_return(msg);
if (reply == NULL)
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);
if (hr->has_location) {
char *loc = g_strdup(location2str(hr->location));
if (loc) {
dict_append_entry(&dict, "Location",
DBUS_TYPE_STRING, &loc);
g_free(loc);
}
}
has_reset = !!hr->hrcp_val_handle;
dict_append_entry(&dict, "ResetSupported", DBUS_TYPE_BOOLEAN,
&has_reset);
dbus_message_iter_close_container(&iter, &dict);
return reply;
}
static void xml_element(GMarkupParseContext *ctxt,
const gchar *element,
const gchar **names,
const gchar **values,
gpointer user_data,
GError **gerr)
{
DBusMessageIter dict, *iter = user_data;
gchar *key;
gint i;
if (strcasecmp("folder", element) != 0 && strcasecmp("file", element) != 0)
return;
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, "Type", DBUS_TYPE_STRING, &element);
/* FIXME: User, Group, Other permission must be reviewed */
i = 0;
for (key = (gchar *) names[i]; key; key = (gchar *) names[++i]) {
key[0] = g_ascii_toupper(key[0]);
if (g_str_equal("Size", key) == TRUE) {
guint64 size;
size = g_ascii_strtoll(values[i], NULL, 10);
dict_append_entry(&dict, key, DBUS_TYPE_UINT64, &size);
} else
dict_append_entry(&dict, key, DBUS_TYPE_STRING, &values[i]);
}
dbus_message_iter_close_container(iter, &dict);
}
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 DBusMessage *proxy_get_info(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct serial_proxy *prx = data;
DBusMessage *reply;
DBusMessageIter iter, dict;
dbus_bool_t boolean;
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);
dict_append_entry(&dict, "uuid", DBUS_TYPE_STRING, &prx->uuid128);
dict_append_entry(&dict, "address", DBUS_TYPE_STRING, &prx->address);
if (prx->channel)
dict_append_entry(&dict, "channel",
DBUS_TYPE_BYTE, &prx->channel);
boolean = (prx->io ? TRUE : FALSE);
dict_append_entry(&dict, "enabled", DBUS_TYPE_BOOLEAN, &boolean);
boolean = (prx->rfcomm ? TRUE : FALSE);
dict_append_entry(&dict, "connected", DBUS_TYPE_BOOLEAN, &boolean);
/* If connected: append the remote address */
if (boolean) {
char bda[18];
const char *pstr = bda;
ba2str(&prx->dst, bda);
dict_append_entry(&dict, "address", DBUS_TYPE_STRING, &pstr);
}
dbus_message_iter_close_container(&iter, &dict);
return reply;
}
static gboolean get_metadata(const GDBusPropertyTable *property,
DBusMessageIter *iter, void *data)
{
struct media_item *item = data;
DBusMessageIter dict;
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);
if (g_hash_table_size(item->metadata) > 0)
g_hash_table_foreach(item->metadata, append_metadata, &dict);
else if (item->name != NULL)
dict_append_entry(&dict, "Title", DBUS_TYPE_STRING,
&item->name);
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;
const char *path = device_get_path(m->t->dev);
DBusMessageIter iter;
DBusMessageIter dict;
DBusMessage *msg;
msg = dbus_message_new_method_call(w->srv, w->path,
THERMOMETER_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, "Exponent", DBUS_TYPE_INT16, &m->exp);
dict_append_entry(&dict, "Mantissa", DBUS_TYPE_INT32, &m->mant);
dict_append_entry(&dict, "Unit", DBUS_TYPE_STRING, &m->unit);
if (m->suptime)
dict_append_entry(&dict, "Time", DBUS_TYPE_UINT64, &m->time);
dict_append_entry(&dict, "Type", DBUS_TYPE_STRING, &m->type);
dict_append_entry(&dict, "Measurement", DBUS_TYPE_STRING, &m->value);
dbus_message_iter_close_container(&iter, &dict);
dbus_message_set_no_reply(msg, TRUE);
g_dbus_send_message(btd_get_dbus_connection(), msg);
}
static int register_profile(struct bluetooth_profile *profile)
{
DBusMessage *msg;
DBusMessageIter iter, opt;
DBusPendingCall *call;
dbus_bool_t auto_connect = FALSE;
char *xml;
int ret = 0;
profile->path = g_strconcat("/org/bluez/obex/", profile->uuid, NULL);
g_strdelimit(profile->path, "-", '_');
if (!g_dbus_register_interface(connection, profile->path,
"org.bluez.Profile1", profile_methods,
NULL, NULL,
profile, NULL)) {
error("D-Bus failed to register %s", profile->path);
g_free(profile->path);
profile->path = NULL;
return -1;
}
msg = dbus_message_new_method_call("org.bluez", "/org/bluez",
"org.bluez.ProfileManager1",
"RegisterProfile");
dbus_message_iter_init_append(msg, &iter);
dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH,
&profile->path);
dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING,
&profile->uuid);
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,
&opt);
dict_append_entry(&opt, "AutoConnect", DBUS_TYPE_BOOLEAN,
&auto_connect);
if (profile->driver->record) {
if (profile->driver->port != 0)
xml = g_markup_printf_escaped(profile->driver->record,
profile->driver->channel,
profile->driver->name,
profile->driver->port);
else
xml = g_markup_printf_escaped(profile->driver->record,
profile->driver->channel,
profile->driver->name);
dict_append_entry(&opt, "ServiceRecord", DBUS_TYPE_STRING,
&xml);
g_free(xml);
}
dbus_message_iter_close_container(&iter, &opt);
if (!dbus_connection_send_with_reply(connection, msg, &call, -1)) {
ret = -1;
unregister_profile(profile);
goto failed;
}
dbus_pending_call_set_notify(call, register_profile_reply, profile,
NULL);
dbus_pending_call_unref(call);
failed:
dbus_message_unref(msg);
return ret;
}
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);
}
static void get_properties_a2dp(struct media_transport *transport,
DBusMessageIter *dict)
{
dict_append_entry(dict, "Delay", DBUS_TYPE_UINT16, &transport->delay);
}
