static void set_volume(const GDBusPropertyTable *property,
DBusMessageIter *iter, GDBusPendingPropertySet id,
void *data)
{
struct media_transport *transport = data;
struct a2dp_transport *a2dp = transport->data;
uint16_t volume;
if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_UINT16) {
g_dbus_pending_property_error(id,
ERROR_INTERFACE ".InvalidArguments",
"Invalid arguments in method call");
return;
}
dbus_message_iter_get_basic(iter, &volume);
if (volume > 127) {
g_dbus_pending_property_error(id,
ERROR_INTERFACE ".InvalidArguments",
"Invalid arguments in method call");
return;
}
if (a2dp->volume != volume)
avrcp_set_volume(transport->device, volume);
a2dp->volume = volume;
g_dbus_pending_property_success(id);
}
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 player_set_setting(struct media_player *mp,
GDBusPendingPropertySet id,
const char *key, const char *value)
{
struct player_callback *cb = mp->cb;
struct pending_req *p;
if (cb == NULL || cb->cbs->set_setting == NULL) {
g_dbus_pending_property_error(id,
ERROR_INTERFACE ".NotSupported",
"Operation is not supported");
return;
}
p = find_pending(mp, key);
if (p != NULL) {
g_dbus_pending_property_error(id,
ERROR_INTERFACE ".InProgress",
"Operation already in progress");
return;
}
if (!cb->cbs->set_setting(mp, key, value, cb->user_data)) {
g_dbus_pending_property_error(id,
ERROR_INTERFACE ".InvalidArguments",
"Invalid arguments in method call");
return;
}
p = pending_new(id, key, value);
mp->pending = g_slist_append(mp->pending, p);
}
static void controlpoint_property_reply(struct controlpoint_req *req,
uint8_t code)
{
switch (code) {
case RSP_SUCCESS:
g_dbus_pending_property_success(req->reply_id);
break;
case RSP_NOT_SUPPORTED:
g_dbus_pending_property_error(req->reply_id,
ERROR_INTERFACE ".NotSupported",
"Feature is not supported");
break;
case RSP_INVALID_PARAM:
g_dbus_pending_property_error(req->reply_id,
ERROR_INTERFACE ".InvalidArguments",
"Invalid arguments in method call");
break;
case RSP_FAILED:
g_dbus_pending_property_error(req->reply_id,
ERROR_INTERFACE ".Failed",
"Operation failed");
break;
default:
g_dbus_pending_property_error(req->reply_id,
ERROR_INTERFACE ".Failed",
"Operation failed (%d)", code);
break;
}
}
static void property_set_location(const GDBusPropertyTable *property,
DBusMessageIter *iter,
GDBusPendingPropertySet id, void *data)
{
struct csc *csc = data;
char *loc;
int loc_val;
uint8_t att_val[2];
struct controlpoint_req *req;
if (csc->pending_req != NULL) {
g_dbus_pending_property_error(id,
ERROR_INTERFACE ".InProgress",
"Operation already in progress");
return;
}
if (!(csc->feature & MULTI_SENSOR_LOC_SUPPORT)) {
g_dbus_pending_property_error(id,
ERROR_INTERFACE ".NotSupported",
"Feature is not supported");
return;
}
if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_STRING) {
g_dbus_pending_property_error(id,
ERROR_INTERFACE ".InvalidArguments",
"Invalid arguments in method call");
return;
}
dbus_message_iter_get_basic(iter, &loc);
loc_val = str2location(loc);
if (loc_val < 0) {
g_dbus_pending_property_error(id,
ERROR_INTERFACE ".InvalidArguments",
"Invalid arguments in method call");
return;
}
req = g_new(struct controlpoint_req, 1);
req->csc = csc;
req->reply_id = id;
req->opcode = UPDATE_SENSOR_LOC;
req->pending_location = loc_val;
csc->pending_req = req;
att_val[0] = UPDATE_SENSOR_LOC;
att_val[1] = loc_val;
gatt_write_char(csc->attrib, csc->controlpoint_val_handle, att_val,
sizeof(att_val), controlpoint_write_cb, req);
}
static void property_set_immediate_alert_level(
const GDBusPropertyTable *property, DBusMessageIter *iter,
GDBusPendingPropertySet id, void *data)
{
struct monitor *monitor = data;
struct btd_device *device = monitor->device;
const char *level;
if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_STRING) {
g_dbus_pending_property_error(id,
ERROR_INTERFACE ".InvalidArguments",
"Invalid arguments in method call");
return;
}
dbus_message_iter_get_basic(iter, &level);
if (!level_is_valid(level)) {
g_dbus_pending_property_error(id,
ERROR_INTERFACE ".InvalidArguments",
"Invalid arguments in method call");
return;
}
if (g_strcmp0(monitor->immediatelevel, level) == 0)
goto done;
if (monitor->immediateto) {
g_source_remove(monitor->immediateto);
monitor->immediateto = 0;
}
/* Previous Immediate Alert level if connection/write fails */
g_free(monitor->fallbacklevel);
monitor->fallbacklevel = monitor->immediatelevel;
monitor->immediatelevel = g_strdup(level);
/*
* Means that Link/Path Loss are disabled or there is a pending
* writting for Find Me(Immediate Alert characteristic value).
* If enabled, Path Loss always registers a connection callback
* when the Proximity Monitor starts.
*/
if (monitor->attioid == 0)
monitor->attioid = btd_device_add_attio_callback(device,
attio_connected_cb,
attio_disconnected_cb,
monitor);
else if (monitor->attrib)
write_immediate_alert(monitor);
done:
g_dbus_pending_property_success(id);
}
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");
}
static void controlpoint_write_cb(guint8 status, const guint8 *pdu, guint16 len,
gpointer user_data)
{
struct controlpoint_req *req = user_data;
if (status == 0) {
req->timeout = g_timeout_add_seconds(ATT_TIMEOUT,
controlpoint_timeout,
req);
return;
}
error("SC Control Point write failed (opcode=%d)", req->opcode);
if (req->opcode == UPDATE_SENSOR_LOC) {
g_dbus_pending_property_error(req->reply_id,
ERROR_INTERFACE ".Failed",
"Operation failed (%d)", status);
} else if (req->opcode == SET_CUMULATIVE_VALUE) {
DBusMessage *reply;
reply = btd_error_failed(req->msg, "Operation failed");
g_dbus_send_message(btd_get_dbus_connection(), reply);
dbus_message_unref(req->msg);
}
req->csc->pending_req = NULL;
g_free(req);
}
static void set_status(const GDBusPropertyTable *property,
DBusMessageIter *iter, GDBusPendingPropertySet id,
uint8_t status, void *data)
{
struct map_msg *msg = data;
struct obc_transfer *transfer;
gboolean value;
GError *err = NULL;
GObexApparam *apparam;
char contents[2];
if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_BOOLEAN) {
g_dbus_pending_property_error(id,
ERROR_INTERFACE ".InvalidArguments",
"Invalid arguments in method call");
return;
}
dbus_message_iter_get_basic(iter, &value);
contents[0] = FILLER_BYTE;
contents[1] = '\0';
transfer = obc_transfer_put("x-bt/messageStatus", msg->handle, NULL,
contents, sizeof(contents), &err);
if (transfer == NULL)
goto fail;
apparam = g_obex_apparam_set_uint8(NULL, MAP_AP_STATUSINDICATOR,
status);
apparam = g_obex_apparam_set_uint8(apparam, MAP_AP_STATUSVALUE,
value);
obc_transfer_set_apparam(transfer, apparam);
if (!obc_session_queue(msg->data->session, transfer,
set_message_status_cb, msg, &err))
goto fail;
msg->pending = id;
return;
fail:
g_dbus_pending_property_error(id, ERROR_INTERFACE ".Failed", "%s",
err->message);
g_error_free(err);
}
void media_player_set_setting(struct media_player *mp, const char *key,
const char *value)
{
char *curval;
struct pending_req *p;
DBG("%s: %s", key, value);
if (strcasecmp(key, "Error") == 0) {
p = g_slist_nth_data(mp->pending, 0);
if (p == NULL)
return;
g_dbus_pending_property_error(p->id, ERROR_INTERFACE ".Failed",
value);
goto send;
}
curval = g_hash_table_lookup(mp->settings, key);
if (g_strcmp0(curval, value) == 0)
goto done;
g_hash_table_replace(mp->settings, g_strdup(key), g_strdup(value));
g_dbus_emit_property_changed(btd_get_dbus_connection(), mp->path,
MEDIA_PLAYER_INTERFACE, key);
done:
p = find_pending(mp, key);
if (p == NULL)
return;
if (strcasecmp(value, p->value) == 0)
g_dbus_pending_property_success(p->id);
else
g_dbus_pending_property_error(p->id,
ERROR_INTERFACE ".NotSupported",
"Operation is not supported");
send:
mp->pending = g_slist_remove(mp->pending, p);
g_free(p);
return;
}
static void property_set_link_loss_level(const GDBusPropertyTable *property,
DBusMessageIter *iter, GDBusPendingPropertySet id, void *data)
{
struct monitor *monitor = data;
const char *level;
if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_STRING) {
g_dbus_pending_property_error(id,
ERROR_INTERFACE ".InvalidArguments",
"Invalid arguments in method call");
return;
}
dbus_message_iter_get_basic(iter, &level);
if (!level_is_valid(level)) {
g_dbus_pending_property_error(id,
ERROR_INTERFACE ".InvalidArguments",
"Invalid arguments in method call");
return;
}
if (g_strcmp0(monitor->linklosslevel, level) == 0)
goto done;
g_free(monitor->linklosslevel);
monitor->linklosslevel = g_strdup(level);
write_proximity_config(monitor->device, "LinkLossAlertLevel", level);
if (monitor->attrib)
write_alert_level(monitor);
done:
g_dbus_pending_property_success(id);
}
static void property_set_powered(const GDBusPropertyTable *property,
DBusMessageIter *value,
GDBusPendingPropertySet id, void *data)
{
dbus_bool_t powered;
if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_BOOLEAN) {
g_dbus_pending_property_error(id,
NFC_ERROR_INTERFACE ".InvalidArguments",
"Invalid arguments in method call");
return;
}
dbus_message_iter_get_basic(value, &powered);
set_powered(id, powered, data);
}
static void set_message_status_cb(struct obc_session *session,
struct obc_transfer *transfer,
GError *err, void *user_data)
{
struct map_msg *msg = user_data;
if (err != NULL) {
g_dbus_pending_property_error(msg->pending,
ERROR_INTERFACE ".Failed",
"%s", err->message);
goto done;
}
g_dbus_pending_property_success(msg->pending);
done:
msg->pending = 0;
}
static void chr_set_value(const GDBusPropertyTable *property,
DBusMessageIter *iter,
GDBusPendingPropertySet id, void *user_data)
{
struct characteristic *chr = user_data;
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;
}
chr_write(chr, iter);
g_dbus_pending_property_success(id);
}
static void set_setting(const GDBusPropertyTable *property,
DBusMessageIter *iter, GDBusPendingPropertySet id,
void *data)
{
struct media_player *mp = data;
const char *value, *current;
if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_STRING) {
g_dbus_pending_property_error(id,
ERROR_INTERFACE ".InvalidArguments",
"Invalid arguments in method call");
return;
}
dbus_message_iter_get_basic(iter, &value);
current = g_hash_table_lookup(mp->settings, property->name);
if (g_strcmp0(current, value) == 0) {
g_dbus_pending_property_success(id);
return;
}
player_set_setting(mp, id, property->name, value);
}
static gboolean controlpoint_timeout(gpointer user_data)
{
struct controlpoint_req *req = user_data;
if (req->opcode == UPDATE_SENSOR_LOC) {
g_dbus_pending_property_error(req->reply_id,
ERROR_INTERFACE ".Failed",
"Operation failed (timeout)");
} else if (req->opcode == SET_CUMULATIVE_VALUE) {
DBusMessage *reply;
reply = btd_error_failed(req->msg,
"Operation failed (timeout)");
g_dbus_send_message(btd_get_dbus_connection(), reply);
dbus_message_unref(req->msg);
}
req->csc->pending_req = NULL;
g_free(req);
return FALSE;
}
