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); }