static gboolean bnep_watchdog_cb(GIOChannel *chan, GIOCondition cond,
gpointer data)
{
struct network_conn *nc = data;
DBusConnection *conn = btd_get_dbus_connection();
const char *path = device_get_path(nc->peer->device);
g_dbus_emit_property_changed(conn, path,
NETWORK_PEER_INTERFACE, "Connected");
g_dbus_emit_property_changed(conn, path,
NETWORK_PEER_INTERFACE, "Interface");
g_dbus_emit_property_changed(conn, path,
NETWORK_PEER_INTERFACE, "UUID");
device_remove_disconnect_watch(nc->peer->device, nc->dc_id);
nc->dc_id = 0;
btd_service_disconnecting_complete(nc->service, 0);
info("%s disconnected", nc->dev);
bnep_if_down(nc->dev);
nc->state = DISCONNECTED;
memset(nc->dev, 0, sizeof(nc->dev));
strcpy(nc->dev, "bnep%d");
return FALSE;
}
static void state_changed(struct btd_device *dev, avctp_state_t old_state,
avctp_state_t new_state, void *user_data)
{
struct control *control = user_data;
DBusConnection *conn = btd_get_dbus_connection();
const char *path = device_get_path(dev);
switch (new_state) {
case AVCTP_STATE_DISCONNECTED:
control->session = NULL;
g_dbus_emit_property_changed(conn, path,
AUDIO_CONTROL_INTERFACE, "Connected");
break;
case AVCTP_STATE_CONNECTING:
if (control->session)
break;
control->session = avctp_get(dev);
break;
case AVCTP_STATE_CONNECTED:
g_dbus_emit_property_changed(conn, path,
AUDIO_CONTROL_INTERFACE, "Connected");
break;
default:
return;
}
}
static void media_player_change_scope(struct media_player *mp,
struct media_folder *folder)
{
struct player_callback *cb = mp->cb;
int err;
if (mp->scope == folder)
return;
DBG("%s", folder->item->name);
/* Skip setting current folder if folder is current playlist/search */
if (folder == mp->playlist || folder == mp->search)
goto cleanup;
mp->folder = folder;
/* Skip item cleanup if scope is the current playlist */
if (mp->scope == mp->playlist)
goto done;
cleanup:
g_slist_free_full(mp->scope->items, media_item_destroy);
mp->scope->items = NULL;
/* Destroy search folder if it exists and is not being set as scope */
if (mp->search != NULL && folder != mp->search) {
mp->folders = g_slist_remove(mp->folders, mp->search);
media_folder_destroy(mp->search);
mp->search = NULL;
}
done:
mp->scope = folder;
if (cb->cbs->total_items) {
err = cb->cbs->total_items(mp, folder->item->name,
cb->user_data);
if (err < 0)
DBG("Failed to get total num of items");
} else {
g_dbus_emit_property_changed(btd_get_dbus_connection(),
mp->path, MEDIA_FOLDER_INTERFACE,
"NumberOfItems");
}
g_dbus_emit_property_changed(btd_get_dbus_connection(), mp->path,
MEDIA_FOLDER_INTERFACE, "Name");
}
static void read_location_cb(guint8 status, const guint8 *pdu,
guint16 len, gpointer user_data)
{
struct csc *csc = user_data;
uint8_t value;
ssize_t vlen;
if (status) {
error("Sensor Location read failed: %s", att_ecode2str(status));
return;
}
vlen = dec_read_resp(pdu, len, &value, sizeof(value));
if (vlen < 0) {
error("Protocol error");
return;
}
if (vlen != sizeof(value)) {
error("Invalid value length for Sensor Location");
return;
}
csc->has_location = TRUE;
csc->location = value;
g_dbus_emit_property_changed(btd_get_dbus_connection(),
device_get_path(csc->dev),
CYCLINGSPEED_INTERFACE, "Location");
}
static gboolean immediate_timeout(gpointer user_data)
{
struct monitor *monitor = user_data;
const char *path = device_get_path(monitor->device);
monitor->immediateto = 0;
if (g_strcmp0(monitor->immediatelevel, "none") == 0)
return FALSE;
if (monitor->attrib) {
uint8_t value = ALERT_NONE;
gatt_write_cmd(monitor->attrib, monitor->immediatehandle,
&value, 1, NULL, NULL);
}
g_free(monitor->immediatelevel);
monitor->immediatelevel = g_strdup("none");
g_dbus_emit_property_changed(btd_get_dbus_connection(), path,
PROXIMITY_INTERFACE, "ImmediateAlertLevel");
return FALSE;
}
static void register_notify_cb(uint16_t att_ecode, void *user_data)
{
struct async_dbus_op *op = user_data;
struct notify_client *client = op->data;
struct characteristic *chrc = client->chrc;
DBusMessage *reply;
if (att_ecode) {
queue_remove(chrc->notify_clients, client);
queue_remove(chrc->service->client->all_notify_clients, client);
notify_client_free(client);
reply = create_notify_reply(op, false, att_ecode);
goto done;
}
if (!chrc->notifying) {
chrc->notifying = true;
g_dbus_emit_property_changed(btd_get_dbus_connection(),
chrc->path, GATT_CHARACTERISTIC_IFACE,
"Notifying");
}
reply = create_notify_reply(op, true, 0);
done:
if (reply)
g_dbus_send_message(btd_get_dbus_connection(), reply);
}
static void chr_set_value(const GDBusPropertyTable *property,
DBusMessageIter *iter,
GDBusPendingPropertySet id, void *user_data)
{
struct characteristic *chr = user_data;
DBusMessageIter array;
uint8_t *value;
int len;
printf("Characteristic(%s): Set('Value', ...)\n", chr->uuid);
if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY) {
printf("Invalid value for Set('Value'...)\n");
g_dbus_pending_property_error(id,
ERROR_INTERFACE ".InvalidArguments",
"Invalid arguments in method call");
return;
}
dbus_message_iter_recurse(iter, &array);
dbus_message_iter_get_fixed_array(&array, &value, &len);
g_free(chr->value);
chr->value = g_memdup(value, len);
chr->vlen = len;
g_dbus_pending_property_success(id);
g_dbus_emit_property_changed(connection, chr->path,
GATT_CHR_IFACE, "Value");
}
void manager_emit_transfer_started(struct obex_transfer *transfer)
{
transfer->status = TRANSFER_STATUS_ACTIVE;
g_dbus_emit_property_changed(connection, transfer->path,
TRANSFER_INTERFACE, "Status");
}
static void read_ext_props_cb(bool success, uint8_t att_ecode,
const uint8_t *value, uint16_t length,
void *user_data)
{
struct characteristic *chrc = user_data;
struct service *service = chrc->service;
if (!success) {
error("Failed to obtain extended properties - error: 0x%02x",
att_ecode);
return;
}
if (!value || length != 2) {
error("Malformed extended properties value");
return;
}
chrc->ext_props = get_le16(value);
if (chrc->ext_props)
g_dbus_emit_property_changed(btd_get_dbus_connection(),
service->path,
GATT_SERVICE_IFACE, "Flags");
queue_remove(service->pending_ext_props, chrc);
notify_chrcs(service);
}
static void set_powered(GDBusPendingPropertySet id, dbus_bool_t powered,
void *data)
{
struct near_adapter *adapter = data;
int err;
err = __near_netlink_adapter_enable(adapter->idx, powered);
if (err < 0) {
if (err == -EALREADY) {
if (powered)
g_dbus_pending_property_error(id,
NFC_ERROR_INTERFACE ".Failed",
"Device already enabled");
else
g_dbus_pending_property_error(id,
NFC_ERROR_INTERFACE ".Failed",
"Device already disabled");
}
g_dbus_pending_property_error(id,
NFC_ERROR_INTERFACE ".Failed",
strerror(err));
return;
}
g_dbus_pending_property_success(id);
adapter->powered = powered;
g_dbus_emit_property_changed(connection, adapter->path,
NFC_ADAPTER_INTERFACE, "Powered");
}
static void sap_io_destroy(void *data)
{
struct sap_server *server = data;
struct sap_connection *conn = server->conn;
DBG("conn %p", conn);
if (!conn || !conn->io)
return;
stop_guard_timer(server);
if (conn->state != SAP_STATE_CONNECT_IN_PROGRESS &&
conn->state != SAP_STATE_CONNECT_MODEM_BUSY)
g_dbus_emit_property_changed(btd_get_dbus_connection(),
adapter_get_path(server->adapter),
SAP_SERVER_INTERFACE,
"Connected");
if (conn->state == SAP_STATE_CONNECT_IN_PROGRESS ||
conn->state == SAP_STATE_CONNECT_MODEM_BUSY ||
conn->state == SAP_STATE_CONNECTED ||
conn->state == SAP_STATE_GRACEFUL_DISCONNECT)
sap_disconnect_req(server, 1);
sap_server_remove_conn(server);
}
static void sap_set_connected(struct sap_server *server)
{
server->conn->state = SAP_STATE_CONNECTED;
g_dbus_emit_property_changed(btd_get_dbus_connection(),
adapter_get_path(server->adapter),
SAP_SERVER_INTERFACE, "Connected");
}
static void emit_transfer_progress(struct obex_transfer *transfer,
uint32_t total, uint32_t transferred)
{
if (transfer->path == NULL)
return;
g_dbus_emit_property_changed(connection, transfer->path,
TRANSFER_INTERFACE, "Transferred");
}
void manager_emit_transfer_property(struct obex_transfer *transfer,
char *name)
{
if (!transfer->path)
return;
g_dbus_emit_property_changed(connection, transfer->path,
TRANSFER_INTERFACE, name);
}
static void bnep_conn_cb(GIOChannel *chan, char *iface, int err, void *data)
{
struct network_conn *nc = data;
const char *path;
DBusConnection *conn;
DBG("");
if (err < 0) {
error("connect failed %s", strerror(-err));
goto failed;
}
info("%s connected", nc->dev);
memcpy(nc->dev, iface, sizeof(nc->dev));
btd_service_connecting_complete(nc->service, 0);
if (nc->connect)
local_connect_cb(nc, 0);
conn = btd_get_dbus_connection();
path = device_get_path(nc->peer->device);
g_dbus_emit_property_changed(conn, path,
NETWORK_PEER_INTERFACE, "Connected");
g_dbus_emit_property_changed(conn, path,
NETWORK_PEER_INTERFACE, "Interface");
g_dbus_emit_property_changed(conn, path,
NETWORK_PEER_INTERFACE, "UUID");
nc->state = CONNECTED;
nc->dc_id = device_add_disconnect_watch(nc->peer->device, disconnect_cb,
nc, NULL);
g_io_add_watch(chan, G_IO_ERR | G_IO_HUP | G_IO_NVAL,
bnep_watchdog_cb, nc);
g_io_channel_unref(nc->io);
nc->io = NULL;
return;
failed:
cancel_connection(nc, -EIO);
}
void media_item_set_playable(struct media_item *item, bool value)
{
if (item->playable == value)
return;
item->playable = value;
g_dbus_emit_property_changed(btd_get_dbus_connection(), item->path,
MEDIA_ITEM_INTERFACE, "Playable");
}
static void write_characteristic_cb(struct gatt_db_attribute *attr, int err,
void *user_data)
{
struct characteristic *chrc = user_data;
if (err)
return;
g_dbus_emit_property_changed(btd_get_dbus_connection(), chrc->path,
GATT_CHARACTERISTIC_IFACE, "Value");
}
static void write_descriptor_cb(struct gatt_db_attribute *attr, int err,
void *user_data)
{
struct descriptor *desc = user_data;
if (err)
return;
g_dbus_emit_property_changed(btd_get_dbus_connection(), desc->path,
GATT_DESCRIPTOR_IFACE, "Value");
}
static void emit_transfer_completed(struct obex_transfer *transfer,
gboolean success)
{
if (transfer->path == NULL)
return;
transfer->status = success ? TRANSFER_STATUS_COMPLETE :
TRANSFER_STATUS_ERROR;
g_dbus_emit_property_changed(connection, transfer->path,
TRANSFER_INTERFACE, "Status");
}
static gboolean process_metadata_changed(void *user_data)
{
struct media_player *mp = user_data;
const char *item;
mp->process_id = 0;
g_dbus_emit_property_changed(btd_get_dbus_connection(),
mp->path, MEDIA_PLAYER_INTERFACE,
"Track");
item = g_hash_table_lookup(mp->track, "Item");
if (item == NULL)
return FALSE;
g_dbus_emit_property_changed(btd_get_dbus_connection(),
item, MEDIA_ITEM_INTERFACE,
"Metadata");
return FALSE;
}
static void notify_chrcs(struct service *service)
{
if (service->chrcs_ready ||
!queue_isempty(service->pending_ext_props))
return;
service->chrcs_ready = true;
g_dbus_emit_property_changed(btd_get_dbus_connection(), service->path,
GATT_SERVICE_IFACE,
"Characteristics");
}
void media_player_set_name(struct media_player *mp, const char *name)
{
if (g_strcmp0(mp->name, name) == 0)
return;
DBG("%s", name);
mp->name = g_strdup(name);
g_dbus_emit_property_changed(btd_get_dbus_connection(),
mp->path, MEDIA_PLAYER_INTERFACE,
"Name");
}
void media_player_set_subtype(struct media_player *mp, const char *subtype)
{
if (g_strcmp0(mp->subtype, subtype) == 0)
return;
DBG("%s", subtype);
mp->subtype = g_strdup(subtype);
g_dbus_emit_property_changed(btd_get_dbus_connection(),
mp->path, MEDIA_PLAYER_INTERFACE,
"Subtype");
}
void media_player_set_searchable(struct media_player *mp, bool enabled)
{
if (mp->browsable == enabled)
return;
DBG("%s", enabled ? "true" : "false");
mp->searchable = enabled;
g_dbus_emit_property_changed(btd_get_dbus_connection(),
mp->path, MEDIA_PLAYER_INTERFACE,
"Searchable");
}
void media_player_set_position(struct media_player *mp, uint32_t position)
{
DBG("%u", position);
/* Only update duration if track exists */
if (g_hash_table_size(mp->track) == 0)
return;
mp->position = position;
g_timer_start(mp->progress);
g_dbus_emit_property_changed(btd_get_dbus_connection(), mp->path,
MEDIA_PLAYER_INTERFACE, "Position");
}
static void update_notifying(struct characteristic *chrc)
{
if (!chrc->notifying)
return;
if (queue_find(chrc->notify_clients, match_notifying, NULL))
return;
chrc->notifying = false;
g_dbus_emit_property_changed(btd_get_dbus_connection(), chrc->path,
GATT_CHARACTERISTIC_IFACE,
"Notifying");
}
static void immediate_written(gpointer user_data)
{
struct monitor *monitor = user_data;
const char *path = device_get_path(monitor->device);
g_free(monitor->fallbacklevel);
monitor->fallbacklevel = NULL;
g_dbus_emit_property_changed(btd_get_dbus_connection(), path,
PROXIMITY_INTERFACE, "ImmediateAlertLevel");
monitor->immediateto = g_timeout_add_seconds(IMMEDIATE_TIMEOUT,
immediate_timeout, monitor);
}
void media_transport_update_delay(struct media_transport *transport,
uint16_t delay)
{
struct a2dp_transport *a2dp = transport->data;
/* Check if delay really changed */
if (a2dp->delay == delay)
return;
a2dp->delay = delay;
g_dbus_emit_property_changed(btd_get_dbus_connection(),
transport->path,
MEDIA_TRANSPORT_INTERFACE, "Delay");
}
void media_transport_update_volume(struct media_transport *transport,
uint8_t volume)
{
struct a2dp_transport *a2dp = transport->data;
/* Check if volume really changed */
if (a2dp->volume == volume)
return;
a2dp->volume = volume;
g_dbus_emit_property_changed(btd_get_dbus_connection(),
transport->path,
MEDIA_TRANSPORT_INTERFACE, "Volume");
}
static void imm_alert_emit_alert_signal(struct connected_device *condev,
uint8_t alert_level)
{
const char *path, *alert_level_str;
if (!condev)
return;
path = device_get_path(condev->device);
alert_level_str = get_alert_level_string(alert_level);
DBG("alert %s remote %s", alert_level_str, path);
g_dbus_emit_property_changed(btd_get_dbus_connection(), path,
PROXIMITY_REPORTER_INTERFACE, "ImmediateAlertLevel");
}