static GVariant*
_field_to_gvariant(gpointer bean, guint position)
{
gpointer pf = FIELD(bean, position);
if (!_bean_has_field(bean, position))
return g_variant_new_tuple(NULL, 0);
switch (DESCR_FIELD(bean,position)->type) {
case FT_BOOL:
return g_variant_new_byte(*((gboolean*)pf) ? 1 : 0);
case FT_INT:
return g_variant_new_int64(*((gint64*)pf));
case FT_REAL:
return g_variant_new_double(*((gdouble*)pf));
case FT_TEXT:
if (!*((gpointer*)(pf)))
return g_variant_new_tuple(NULL, 0);
return g_variant_new_string(GSTR(pf)->str);
case FT_BLOB:
if (!*((gpointer*)(pf)))
return g_variant_new_tuple(NULL, 0);
return _gba_to_gvariant(GBA(pf));
default:
g_assert_not_reached();
break;
}
g_assert_not_reached();
return NULL;
}
GVariant* GnomeGrabber::Impl::onShellMethodCall(std::string const& method, GVariant* parameters)
{
LOG_DEBUG(logger) << "Called method '" << method << "'";
if (method == "GrabAccelerators")
{
if (g_variant_is_of_type(parameters, G_VARIANT_TYPE("(a(su))")))
{
GVariant* variant;
GVariantBuilder builder;
GVariantIter* iterator;
gchar const* accelerator;
guint flags;
g_variant_builder_init(&builder, G_VARIANT_TYPE("au"));
g_variant_get(parameters, "(a(su))", &iterator);
while (g_variant_iter_next(iterator, "(&su)", &accelerator, &flags))
g_variant_builder_add(&builder, "u", grabAccelerator(accelerator, flags));
g_variant_iter_free(iterator);
variant = g_variant_builder_end(&builder);
return g_variant_new_tuple(&variant, 1);
}
else
LOG_WARN(logger) << "Expected arguments of type (a(su))";
}
else if (method == "GrabAccelerator")
{
if (g_variant_is_of_type(parameters, G_VARIANT_TYPE("(su)")))
{
GVariant* variant;
gchar const* accelerator;
guint flags;
g_variant_get(parameters, "(&su)", &accelerator, &flags);
variant = g_variant_new_uint32(grabAccelerator(accelerator, flags));
return g_variant_new_tuple(&variant, 1);
}
else
LOG_WARN(logger) << "Expected arguments of type (su)";
}
else if (method == "UngrabAccelerator")
{
if (g_variant_is_of_type(parameters, G_VARIANT_TYPE("(u)")))
{
GVariant* variant;
guint action;
g_variant_get(parameters, "(u)", &action);
variant = g_variant_new_boolean(removeAction(action));
return g_variant_new_tuple(&variant, 1);
}
else
LOG_WARN(logger) << "Expected arguments of type (u)";
}
return nullptr;
}
static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi)
{
GVariant *tuple, *rational[2];
GVariantBuilder gvb;
unsigned int i;
struct dev_context *devc;
switch (key) {
case SR_CONF_SCAN_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
hwopts, ARRAY_SIZE(hwopts), sizeof(int32_t));
break;
case SR_CONF_DEVICE_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
break;
case SR_CONF_COUPLING:
*data = g_variant_new_strv(coupling, ARRAY_SIZE(coupling));
break;
case SR_CONF_VDIV:
g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
for (i = 0; i < ARRAY_SIZE(vdivs); i++) {
rational[0] = g_variant_new_uint64(vdivs[i][0]);
rational[1] = g_variant_new_uint64(vdivs[i][1]);
tuple = g_variant_new_tuple(rational, 2);
g_variant_builder_add_value(&gvb, tuple);
}
*data = g_variant_builder_end(&gvb);
break;
case SR_CONF_TIMEBASE:
g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
for (i = 0; i < ARRAY_SIZE(timebases); i++) {
rational[0] = g_variant_new_uint64(timebases[i][0]);
rational[1] = g_variant_new_uint64(timebases[i][1]);
tuple = g_variant_new_tuple(rational, 2);
g_variant_builder_add_value(&gvb, tuple);
}
*data = g_variant_builder_end(&gvb);
break;
case SR_CONF_TRIGGER_SOURCE:
if (!sdi || !sdi->priv)
/* Can't know this until we have the exact model. */
return SR_ERR_ARG;
devc = sdi->priv;
*data = g_variant_new_strv(trigger_sources,
devc->has_digital ? ARRAY_SIZE(trigger_sources) : 4);
break;
default:
return SR_ERR_NA;
}
return SR_OK;
}
static void Get(cDBusObject *Object, GVariant *Parameters, GDBusMethodInvocation *Invocation)
{
// only update recordings list if empty
// so we don't mess around with the index values returned by List
if (recordings.Count() == 0)
recordings.Update(true);
cRecording *recording = NULL;
GVariant *first = g_variant_get_child_value(Parameters, 0);
GVariant *refValue = first;
if (g_variant_is_of_type(first, G_VARIANT_TYPE_VARIANT))
refValue = g_variant_get_child_value(first, 0);
if (g_variant_is_of_type(refValue, G_VARIANT_TYPE_STRING)) {
const char *path = NULL;
g_variant_get(refValue, "&s", &path);
if ((path != NULL) && *path)
recording = recordings.GetByName(path);
}
else if (g_variant_is_of_type(refValue, G_VARIANT_TYPE_INT32)) {
int number = 0;
g_variant_get(refValue, "i", &number);
if ((number > 0) && (number <= recordings.Count()))
recording = recordings.Get(number - 1);
}
if (refValue != first)
g_variant_unref(refValue);
g_variant_unref(first);
GVariant *rec = BuildRecording(recording);
g_dbus_method_invocation_return_value(Invocation, g_variant_new_tuple(&rec, 1));
};
void
gst_switch_controller_show_track_marker (GstSwitchController * controller,
GVariant * faces)
{
gst_switch_controller_emit_signal (controller, "show_track_marker",
g_variant_new_tuple (&faces, 1));
}
static void
infinoted_plugin_dbus_set_acl_finished_cb(InfRequest* request,
const InfRequestResult* result,
const GError* error,
gpointer user_data)
{
InfinotedPluginDbusInvocation* invocation;
invocation = (InfinotedPluginDbusInvocation*)user_data;
invocation->request = NULL;
if(error != NULL)
{
g_dbus_method_invocation_return_error_literal(
invocation->invocation,
G_DBUS_ERROR,
G_DBUS_ERROR_INVALID_ARGS,
error->message
);
}
else
{
g_dbus_method_invocation_return_value(
invocation->invocation,
g_variant_new_tuple(NULL, 0)
);
}
infinoted_plugin_dbus_invocation_free(invocation->plugin, invocation);
}
static int
spawn (const gchar *app,
GError **error)
{
G_PASTE_CLEANUP_FREE gchar *name = g_strdup_printf ("org.gnome.GPaste.%s", app);
G_PASTE_CLEANUP_FREE gchar *object = g_strdup_printf ("/org/gnome/GPaste/%s", app);
G_PASTE_CLEANUP_UNREF GDBusProxy *proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
G_DBUS_PROXY_FLAGS_NONE,
NULL,
name,
object,
"org.freedesktop.Application",
NULL,
error);
if (proxy)
{
GVariant *param = g_variant_new ("a{sv}", NULL);
GVariant *params = g_variant_new_tuple (¶m, 1);
g_dbus_proxy_call_sync (proxy, "Activate", params, G_DBUS_CALL_FLAGS_NONE, -1, NULL, error);
}
if (*error)
{
g_critical ("%s %s: %s", _("Couldn't spawn"), app, (*error)->message);
g_clear_error (error);
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
struct dev_context *devc;
GVariant *range[2];
(void)cg;
if (!sdi)
return SR_ERR_ARG;
devc = sdi->priv;
switch (key) {
case SR_CONF_SAMPLERATE:
*data = g_variant_new_uint64(devc->cur_samplerate);
break;
case SR_CONF_CAPTURE_RATIO:
*data = g_variant_new_uint64(devc->capture_ratio);
break;
case SR_CONF_VOLTAGE_THRESHOLD:
range[0] = g_variant_new_double(devc->cur_threshold);
range[1] = g_variant_new_double(devc->cur_threshold);
*data = g_variant_new_tuple(range, 2);
break;
default:
return SR_ERR_NA;
}
return SR_OK;
}
static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
struct dev_context *devc;
struct sr_usb_dev_inst *usb;
GVariant *range[2];
char str[128];
int ret;
unsigned int i;
(void)cg;
ret = SR_OK;
switch (key) {
case SR_CONF_CONN:
if (!sdi || !sdi->conn)
return SR_ERR_ARG;
usb = sdi->conn;
if (usb->address == 255)
/* Device still needs to re-enumerate after firmware
* upload, so we don't know its (future) address. */
return SR_ERR;
snprintf(str, 128, "%d.%d", usb->bus, usb->address);
*data = g_variant_new_string(str);
break;
case SR_CONF_SAMPLERATE:
if (!sdi)
return SR_ERR;
devc = sdi->priv;
*data = g_variant_new_uint64(devc->cur_samplerate);
break;
case SR_CONF_CAPTURE_RATIO:
if (!sdi)
return SR_ERR;
devc = sdi->priv;
*data = g_variant_new_uint64(devc->capture_ratio);
break;
case SR_CONF_VOLTAGE_THRESHOLD:
if (!sdi)
return SR_ERR;
devc = sdi->priv;
ret = SR_ERR;
for (i = 0; i < ARRAY_SIZE(volt_thresholds); i++) {
if (devc->selected_voltage_range !=
volt_thresholds[i].range)
continue;
range[0] = g_variant_new_double(volt_thresholds[i].low);
range[1] = g_variant_new_double(volt_thresholds[i].high);
*data = g_variant_new_tuple(range, 2);
ret = SR_OK;
break;
}
break;
default:
return SR_ERR_NA;
}
return ret;
}
static inline GVariant *
new_param_variant (const char *arg)
{
GVariant * const args[1] = {
g_variant_new_string (arg)
};
return g_variant_new_tuple (args, 1);
}
static GVariant *
parse_json_tuple (JsonNode *node,
const GVariantType *child_type,
GError **error)
{
GVariant *result = NULL;
GPtrArray *children;
GVariant *value;
JsonArray *array;
guint length;
guint i;
children = g_ptr_array_new ();
if (!check_type (node, JSON_NODE_ARRAY, 0, error))
goto out;
array = json_node_get_array (node);
length = json_array_get_length (array);
for (i = 0; i < length; i++)
{
value = NULL;
if (child_type == NULL)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA,
"Too many values in tuple/struct");
}
else
{
value = parse_json (json_array_get_element (array, i),
child_type, error);
}
if (!value)
goto out;
g_ptr_array_add (children, value);
child_type = g_variant_type_next (child_type);
}
if (child_type)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA,
"Too few values in tuple/struct");
goto out;
}
result = g_variant_new_tuple ((GVariant *const *)children->pdata,
children->len);
children->len = 0;
out:
g_ptr_array_foreach (children, (GFunc)g_variant_unref, NULL);
g_ptr_array_free (children, TRUE);
return result;
}
static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
GVariant *tuple, *range[2];
GVariantBuilder gvb;
unsigned int i;
int ret;
(void)cg;
ret = SR_OK;
if (!sdi) {
switch (key) {
case SR_CONF_SCAN_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
break;
case SR_CONF_DEVICE_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
drvopts, ARRAY_SIZE(drvopts), sizeof(uint32_t));
break;
default:
return SR_ERR_NA;
}
} else {
switch (key) {
case SR_CONF_DEVICE_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
break;
case SR_CONF_SPL_WEIGHT_FREQ:
*data = g_variant_new_strv(weight_freq, ARRAY_SIZE(weight_freq));
break;
case SR_CONF_SPL_WEIGHT_TIME:
*data = g_variant_new_strv(weight_time, ARRAY_SIZE(weight_time));
break;
case SR_CONF_SPL_MEASUREMENT_RANGE:
g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
for (i = 0; i < ARRAY_SIZE(meas_ranges); i++) {
range[0] = g_variant_new_uint64(meas_ranges[i][0]);
range[1] = g_variant_new_uint64(meas_ranges[i][1]);
tuple = g_variant_new_tuple(range, 2);
g_variant_builder_add_value(&gvb, tuple);
}
*data = g_variant_builder_end(&gvb);
break;
case SR_CONF_DATA_SOURCE:
*data = g_variant_new_strv(data_sources, ARRAY_SIZE(data_sources));
break;
default:
return SR_ERR_NA;
}
}
return ret;
}
static void List(cDBusObject *Object, GVariant *Parameters, GDBusMethodInvocation *Invocation)
{
recordings.Update(true);
GVariantBuilder *array = g_variant_builder_new(G_VARIANT_TYPE("a(ia(sv))"));
for (cRecording *r = recordings.First(); r; r = recordings.Next(r))
g_variant_builder_add_value(array, BuildRecording(r));
GVariant *a = g_variant_builder_end(array);
g_dbus_method_invocation_return_value(Invocation, g_variant_new_tuple(&a, 1));
g_variant_builder_unref(array);
};
void bluez_unregister_watcher(GDBusConnection* conn, const gchar* service_path)
{
GError* error = NULL;
GDBusMessage* call_message = g_dbus_message_new_method_call("org.bluez",
service_path,
"org.bluez.Characteristic",
"UnregisterCharacteristicsWatcher");
if(call_message == NULL)
{
printf("g_dbus_message_new_method_call failed\n");
return;
}
gchar path[255];
g_snprintf(path, 255, "/test/bluez/%d", getpid());
GVariant* variant_addr = g_variant_new_object_path(path);
GVariant* variant_body = g_variant_new_tuple(&variant_addr, 1);
g_dbus_message_set_body(call_message, variant_body);
GDBusMessage* reply_message = g_dbus_connection_send_message_with_reply_sync(conn,
call_message,
G_DBUS_SEND_MESSAGE_FLAGS_NONE,
-1,
NULL,
NULL,
&error);
if(reply_message == NULL)
{
printf("g_dbus_connection_send_message_with_reply_sync failed\n");
return;
}
if(g_dbus_message_get_message_type(reply_message) == G_DBUS_MESSAGE_TYPE_ERROR)
{
printf("Error occured\n");
g_dbus_message_to_gerror(reply_message, &error);
g_printerr("Error invoking g_dbus_connection_send_message_with_reply_sync: %s\n", error->message);
g_error_free(error);
return;
}
// cleanup
g_object_unref(call_message);
g_object_unref(reply_message);
}
// returns the object path to a given device or NULL if failed
// object path has to be freed with g_free()
gchar* bluez_find_device(GDBusConnection* conn, const gchar* adapter_path, const char* bt_addr)
{
GError* error = NULL;
GDBusMessage* call_message = g_dbus_message_new_method_call("org.bluez",
adapter_path,
"org.bluez.Adapter",
"FindDevice");
if(call_message == NULL)
{
return NULL;
}
GVariant* variant_addr = g_variant_new_string(bt_addr);
GVariant* variant_body = g_variant_new_tuple(&variant_addr, 1);
g_dbus_message_set_body(call_message, variant_body);
GDBusMessage* reply_message = g_dbus_connection_send_message_with_reply_sync(conn,
call_message,
G_DBUS_SEND_MESSAGE_FLAGS_NONE,
-1,
NULL,
NULL,
&error);
if(reply_message == NULL)
{
return NULL;
}
if(g_dbus_message_get_message_type(reply_message) == G_DBUS_MESSAGE_TYPE_ERROR)
{
return NULL;
}
GVariant* variant = g_dbus_message_get_body(reply_message);
// get first child, as this is the object path of the default interface of bluez
GVariant* var_child = g_variant_get_child_value(variant, 0);
const gchar* tmp_path = g_variant_get_string(var_child, NULL);
// copy content of tmp_path to obj_path, as tmp_path gets freed after unref of the variant
gchar* obj_path = g_strdup(tmp_path);
// cleanup
g_variant_unref(var_child);
g_object_unref(call_message);
g_object_unref(reply_message);
return obj_path;
}
static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
GVariant *gvar, *range[2];
GVariantBuilder gvb;
int ret;
unsigned int i;
(void)sdi;
(void)cg;
ret = SR_OK;
switch (key) {
case SR_CONF_SCAN_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
break;
case SR_CONF_DEVICE_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
break;
case SR_CONF_SAMPLERATE:
g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"),
samplerates, ARRAY_SIZE(samplerates), sizeof(uint64_t));
g_variant_builder_add(&gvb, "{sv}", "samplerates", gvar);
*data = g_variant_builder_end(&gvb);
break;
case SR_CONF_VOLTAGE_THRESHOLD:
g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
for (i = 0; i < ARRAY_SIZE(volt_thresholds); i++) {
range[0] = g_variant_new_double(volt_thresholds[i].low);
range[1] = g_variant_new_double(volt_thresholds[i].high);
gvar = g_variant_new_tuple(range, 2);
g_variant_builder_add_value(&gvb, gvar);
}
*data = g_variant_builder_end(&gvb);
break;
case SR_CONF_TRIGGER_MATCH:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
soft_trigger_matches, ARRAY_SIZE(soft_trigger_matches),
sizeof(int32_t));
break;
default:
return SR_ERR_NA;
}
return ret;
}
static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
GVariant *gvar, *grange[2];
GVariantBuilder gvb;
struct dev_context *devc;
(void)cg;
switch (key) {
case SR_CONF_DEVICE_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
break;
case SR_CONF_SAMPLERATE:
if (!sdi || !sdi->priv || !(devc = sdi->priv))
return SR_ERR_BUG;
cv_fill_samplerates_if_needed(sdi);
g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"),
devc->samplerates,
ARRAY_SIZE(devc->samplerates),
sizeof(uint64_t));
g_variant_builder_add(&gvb, "{sv}", "samplerates", gvar);
*data = g_variant_builder_end(&gvb);
break;
case SR_CONF_LIMIT_SAMPLES:
if (!sdi || !sdi->priv || !(devc = sdi->priv) || !devc->prof)
return SR_ERR_BUG;
grange[0] = g_variant_new_uint64(0);
if (devc->prof->model == CHRONOVU_LA8)
grange[1] = g_variant_new_uint64(MAX_NUM_SAMPLES);
else
grange[1] = g_variant_new_uint64(MAX_NUM_SAMPLES / 2);
*data = g_variant_new_tuple(grange, 2);
break;
case SR_CONF_TRIGGER_MATCH:
if (!sdi || !sdi->priv || !(devc = sdi->priv) || !devc->prof)
return SR_ERR_BUG;
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
trigger_matches, devc->prof->num_trigger_matches,
sizeof(int32_t));
break;
default:
return SR_ERR_NA;
}
return SR_OK;
}
static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
struct dev_context *devc;
GVariant *rational[2];
const uint64_t *si;
(void)cg;
devc = sdi->priv;
switch (key) {
case SR_CONF_LIMIT_SAMPLES:
*data = g_variant_new_uint64(devc->limit_samples);
break;
case SR_CONF_SAMPLE_INTERVAL:
si = kecheng_kc_330b_sample_intervals[devc->sample_interval];
rational[0] = g_variant_new_uint64(si[0]);
rational[1] = g_variant_new_uint64(si[1]);
*data = g_variant_new_tuple(rational, 2);
break;
case SR_CONF_DATALOG:
/* There really isn't a way to be sure the device is logging. */
return SR_ERR_NA;
break;
case SR_CONF_SPL_WEIGHT_FREQ:
if (devc->mqflags & SR_MQFLAG_SPL_FREQ_WEIGHT_A)
*data = g_variant_new_string("A");
else
*data = g_variant_new_string("C");
break;
case SR_CONF_SPL_WEIGHT_TIME:
if (devc->mqflags & SR_MQFLAG_SPL_TIME_WEIGHT_F)
*data = g_variant_new_string("F");
else
*data = g_variant_new_string("S");
break;
case SR_CONF_DATA_SOURCE:
if (devc->data_source == DATA_SOURCE_LIVE)
*data = g_variant_new_string("Live");
else
*data = g_variant_new_string("Memory");
break;
default:
return SR_ERR_NA;
}
return SR_OK;
}
static GVariant *build_tuples(const uint64_t (*array)[][2], unsigned int n)
{
unsigned int i;
GVariant *rational[2];
GVariantBuilder gvb;
g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
for (i = 0; i < n; i++) {
rational[0] = g_variant_new_uint64((*array)[i][0]);
rational[1] = g_variant_new_uint64((*array)[i][1]);
/* FIXME: Valgrind reports a memory leak here. */
g_variant_builder_add_value(&gvb, g_variant_new_tuple(rational, 2));
}
return g_variant_builder_end(&gvb);
}
static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
GVariant *gvar, *grange[2];
GVariantBuilder gvb;
int ret;
(void)sdi;
(void)cg;
ret = SR_OK;
switch (key) {
case SR_CONF_DEVICE_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
break;
case SR_CONF_SAMPLERATE:
g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"),
sl2_samplerates, ARRAY_SIZE(sl2_samplerates),
sizeof(uint64_t));
g_variant_builder_add(&gvb, "{sv}", "samplerates", gvar);
*data = g_variant_builder_end(&gvb);
break;
case SR_CONF_TRIGGER_MATCH:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
trigger_matches, ARRAY_SIZE(trigger_matches),
sizeof(int32_t));
break;
case SR_CONF_LIMIT_SAMPLES:
grange[0] = g_variant_new_uint64(0);
grange[1] = g_variant_new_uint64(MAX_SAMPLES);
*data = g_variant_new_tuple(grange, 2);
break;
default:
return SR_ERR_NA;
}
return ret;
}
static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
struct dev_context *devc;
(void)cg;
switch (id) {
case SR_CONF_SAMPLERATE:
if (sdi) {
devc = sdi->priv;
*data = g_variant_new_uint64(devc->cur_samplerate);
sr_spew("Returning samplerate: %" PRIu64 "Hz.",
devc->cur_samplerate);
} else
return SR_ERR_ARG;
break;
case SR_CONF_CAPTURE_RATIO:
if (sdi) {
devc = sdi->priv;
*data = g_variant_new_uint64(devc->capture_ratio);
} else
return SR_ERR_ARG;
break;
case SR_CONF_VOLTAGE_THRESHOLD:
if (sdi) {
GVariant *range[2];
devc = sdi->priv;
range[0] = g_variant_new_double(devc->cur_threshold);
range[1] = g_variant_new_double(devc->cur_threshold);
*data = g_variant_new_tuple(range, 2);
} else
return SR_ERR_ARG;
break;
default:
return SR_ERR_NA;
}
return SR_OK;
}
static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
GVariant *tuple, *rational[2];
GVariantBuilder gvb;
unsigned int i;
(void)sdi;
(void)cg;
switch (key) {
case SR_CONF_DEVICE_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
break;
case SR_CONF_SAMPLE_INTERVAL:
g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
for (i = 0; i < ARRAY_SIZE(kecheng_kc_330b_sample_intervals); i++) {
rational[0] = g_variant_new_uint64(kecheng_kc_330b_sample_intervals[i][0]);
rational[1] = g_variant_new_uint64(kecheng_kc_330b_sample_intervals[i][1]);
tuple = g_variant_new_tuple(rational, 2);
g_variant_builder_add_value(&gvb, tuple);
}
*data = g_variant_builder_end(&gvb);
break;
case SR_CONF_SPL_WEIGHT_FREQ:
*data = g_variant_new_strv(weight_freq, ARRAY_SIZE(weight_freq));
break;
case SR_CONF_SPL_WEIGHT_TIME:
*data = g_variant_new_strv(weight_time, ARRAY_SIZE(weight_time));
break;
case SR_CONF_DATA_SOURCE:
*data = g_variant_new_strv(data_sources, ARRAY_SIZE(data_sources));
break;
default:
return SR_ERR_NA;
}
return SR_OK;
}
static void
done_cb (GObject *const object,
GAsyncResult *const result,
NulMusicService *const music)
{
g_autoptr(GError) error = NULL;
g_autoptr(GTask) task = G_TASK (result);
AsyncSparqlWork *const work = (AsyncSparqlWork *) g_task_propagate_pointer (
task,
&error
);
GDBusMethodInvocation *const invo = work->invo;
GVariant *const variant = work->variant;
g_dbus_method_invocation_return_value (
invo,
g_variant_new_tuple (&variant, 1)
);
}
static int config_get(int key, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
struct dev_context *devc;
GVariant *range[2];
uint64_t low, high;
int tmp, ret;
(void)cg;
if (!sdi)
return SR_ERR_ARG;
devc = sdi->priv;
ret = SR_OK;
switch (key) {
case SR_CONF_LIMIT_SAMPLES:
*data = g_variant_new_uint64(devc->limit_samples);
break;
case SR_CONF_DATALOG:
if ((ret = cem_dt_885x_recording_get(sdi, &tmp)) == SR_OK)
*data = g_variant_new_boolean(tmp);
break;
case SR_CONF_SPL_WEIGHT_FREQ:
tmp = cem_dt_885x_weight_freq_get(sdi);
if (tmp == SR_MQFLAG_SPL_FREQ_WEIGHT_A)
*data = g_variant_new_string("A");
else if (tmp == SR_MQFLAG_SPL_FREQ_WEIGHT_C)
*data = g_variant_new_string("C");
else
return SR_ERR;
break;
case SR_CONF_SPL_WEIGHT_TIME:
tmp = cem_dt_885x_weight_time_get(sdi);
if (tmp == SR_MQFLAG_SPL_TIME_WEIGHT_F)
*data = g_variant_new_string("F");
else if (tmp == SR_MQFLAG_SPL_TIME_WEIGHT_S)
*data = g_variant_new_string("S");
else
return SR_ERR;
break;
case SR_CONF_HOLD_MAX:
if ((ret = cem_dt_885x_holdmode_get(sdi, &tmp)) == SR_OK)
*data = g_variant_new_boolean(tmp == SR_MQFLAG_MAX);
break;
case SR_CONF_HOLD_MIN:
if ((ret = cem_dt_885x_holdmode_get(sdi, &tmp)) == SR_OK)
*data = g_variant_new_boolean(tmp == SR_MQFLAG_MIN);
break;
case SR_CONF_SPL_MEASUREMENT_RANGE:
if ((ret = cem_dt_885x_meas_range_get(sdi, &low, &high)) == SR_OK) {
range[0] = g_variant_new_uint64(low);
range[1] = g_variant_new_uint64(high);
*data = g_variant_new_tuple(range, 2);
}
break;
case SR_CONF_POWER_OFF:
*data = g_variant_new_boolean(FALSE);
break;
case SR_CONF_DATA_SOURCE:
if (devc->cur_data_source == DATA_SOURCE_LIVE)
*data = g_variant_new_string("Live");
else
*data = g_variant_new_string("Memory");
break;
default:
return SR_ERR_NA;
}
return ret;
}
/**
* g_dbus_method_invocation_return_value:
* @invocation: A #GDBusMethodInvocation.
* @parameters: A #GVariant tuple with out parameters for the method or %NULL if not passing any parameters.
*
* Finishes handling a D-Bus method call by returning @parameters.
* If the @parameters GVariant is floating, it is consumed.
*
* It is an error if @parameters is not of the right format.
*
* This method will free @invocation, you cannot use it afterwards.
*
* Since: 2.26
*/
void
g_dbus_method_invocation_return_value (GDBusMethodInvocation *invocation,
GVariant *parameters)
{
GDBusMessage *reply;
GError *error;
g_return_if_fail (G_IS_DBUS_METHOD_INVOCATION (invocation));
g_return_if_fail ((parameters == NULL) || g_variant_is_of_type (parameters, G_VARIANT_TYPE_TUPLE));
if (parameters == NULL)
parameters = g_variant_new_tuple (NULL, 0);
/* if we have introspection data, check that the signature of @parameters is correct */
if (invocation->method_info != NULL)
{
GVariantType *type;
type = _g_dbus_compute_complete_signature (invocation->method_info->out_args);
if (!g_variant_is_of_type (parameters, type))
{
gchar *type_string = g_variant_type_dup_string (type);
g_warning (_("Type of return value is incorrect, got `%s', expected `%s'"),
g_variant_get_type_string (parameters), type_string);
g_variant_type_free (type);
g_free (type_string);
goto out;
}
g_variant_type_free (type);
}
if (G_UNLIKELY (_g_dbus_debug_return ()))
{
_g_dbus_debug_print_lock ();
g_print ("========================================================================\n"
"GDBus-debug:Return:\n"
" >>>> METHOD RETURN\n"
" in response to %s.%s()\n"
" on object %s\n"
" to name %s\n"
" reply-serial %d\n",
invocation->interface_name, invocation->method_name,
invocation->object_path,
invocation->sender,
g_dbus_message_get_serial (invocation->message));
_g_dbus_debug_print_unlock ();
}
reply = g_dbus_message_new_method_reply (invocation->message);
g_dbus_message_set_body (reply, parameters);
error = NULL;
if (!g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, &error))
{
g_warning (_("Error sending message: %s"), error->message);
g_error_free (error);
}
g_object_unref (reply);
out:
g_object_unref (invocation);
}
static void
g_dbus_method_invocation_return_value_internal (GDBusMethodInvocation *invocation,
GVariant *parameters,
GUnixFDList *fd_list)
{
GDBusMessage *reply;
GError *error;
g_return_if_fail (G_IS_DBUS_METHOD_INVOCATION (invocation));
g_return_if_fail ((parameters == NULL) || g_variant_is_of_type (parameters, G_VARIANT_TYPE_TUPLE));
if (parameters == NULL)
parameters = g_variant_new_tuple (NULL, 0);
/* if we have introspection data, check that the signature of @parameters is correct */
if (invocation->method_info != NULL)
{
GVariantType *type;
type = _g_dbus_compute_complete_signature (invocation->method_info->out_args);
if (!g_variant_is_of_type (parameters, type))
{
gchar *type_string = g_variant_type_dup_string (type);
g_warning ("Type of return value is incorrect: expected '%s', got '%s''",
type_string, g_variant_get_type_string (parameters));
g_variant_type_free (type);
g_free (type_string);
goto out;
}
g_variant_type_free (type);
}
/* property_info is only non-NULL if set that way from
* GDBusConnection, so this must be the case of async property
* handling on either 'Get', 'Set' or 'GetAll'.
*/
if (invocation->property_info != NULL)
{
if (g_str_equal (invocation->method_name, "Get"))
{
GVariant *nested;
if (!g_variant_is_of_type (parameters, G_VARIANT_TYPE ("(v)")))
{
g_warning ("Type of return value for property 'Get' call should be '(v)' but got '%s'",
g_variant_get_type_string (parameters));
goto out;
}
/* Go deeper and make sure that the value inside of the
* variant matches the property type.
*/
g_variant_get (parameters, "(v)", &nested);
if (!g_str_equal (g_variant_get_type_string (nested), invocation->property_info->signature))
{
g_warning ("Value returned from property 'Get' call for '%s' should be '%s' but is '%s'",
invocation->property_info->name, invocation->property_info->signature,
g_variant_get_type_string (nested));
g_variant_unref (nested);
goto out;
}
g_variant_unref (nested);
}
else if (g_str_equal (invocation->method_name, "GetAll"))
{
if (!g_variant_is_of_type (parameters, G_VARIANT_TYPE ("(a{sv})")))
{
g_warning ("Type of return value for property 'GetAll' call should be '(a{sv})' but got '%s'",
g_variant_get_type_string (parameters));
goto out;
}
/* Could iterate the list of properties and make sure that all
* of them are actually on the interface and with the correct
* types, but let's not do that for now...
*/
}
else if (g_str_equal (invocation->method_name, "Set"))
{
if (!g_variant_is_of_type (parameters, G_VARIANT_TYPE_UNIT))
{
g_warning ("Type of return value for property 'Set' call should be '()' but got '%s'",
g_variant_get_type_string (parameters));
goto out;
}
}
else
g_assert_not_reached ();
}
if (G_UNLIKELY (_g_dbus_debug_return ()))
{
_g_dbus_debug_print_lock ();
g_print ("========================================================================\n"
"GDBus-debug:Return:\n"
" >>>> METHOD RETURN\n"
" in response to %s.%s()\n"
" on object %s\n"
" to name %s\n"
" reply-serial %d\n",
invocation->interface_name, invocation->method_name,
invocation->object_path,
invocation->sender,
g_dbus_message_get_serial (invocation->message));
_g_dbus_debug_print_unlock ();
}
reply = g_dbus_message_new_method_reply (invocation->message);
g_dbus_message_set_body (reply, parameters);
#ifdef G_OS_UNIX
if (fd_list != NULL)
g_dbus_message_set_unix_fd_list (reply, fd_list);
#endif
error = NULL;
if (!g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, &error))
{
g_warning ("Error sending message: %s", error->message);
g_error_free (error);
}
g_object_unref (reply);
out:
g_object_unref (invocation);
}
static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
struct dev_context *devc;
GVariant *gvar, *grange[2];
GVariantBuilder gvb;
double v;
GVariant *range[2];
(void)cg;
switch (key) {
case SR_CONF_DEVICE_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
break;
case SR_CONF_SAMPLERATE:
devc = sdi->priv;
g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
if (devc->prof->max_sampling_freq == 100) {
gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"),
samplerates_100, ARRAY_SIZE(samplerates_100),
sizeof(uint64_t));
} else if (devc->prof->max_sampling_freq == 200) {
gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"),
samplerates_200, ARRAY_SIZE(samplerates_200),
sizeof(uint64_t));
} else {
sr_err("Internal error: Unknown max. samplerate: %d.",
devc->prof->max_sampling_freq);
return SR_ERR_ARG;
}
g_variant_builder_add(&gvb, "{sv}", "samplerates", gvar);
*data = g_variant_builder_end(&gvb);
break;
case SR_CONF_TRIGGER_TYPE:
*data = g_variant_new_string(TRIGGER_TYPE);
break;
case SR_CONF_VOLTAGE_THRESHOLD:
g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
for (v = -6.0; v <= 6.0; v += 0.1) {
range[0] = g_variant_new_double(v);
range[1] = g_variant_new_double(v);
gvar = g_variant_new_tuple(range, 2);
g_variant_builder_add_value(&gvb, gvar);
}
*data = g_variant_builder_end(&gvb);
break;
case SR_CONF_LIMIT_SAMPLES:
if (!sdi)
return SR_ERR_ARG;
devc = sdi->priv;
grange[0] = g_variant_new_uint64(0);
grange[1] = g_variant_new_uint64(devc->max_sample_depth);
*data = g_variant_new_tuple(grange, 2);
break;
default:
return SR_ERR_NA;
}
return SR_OK;
}
static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_probe_group *probe_group)
{
struct dev_context *devc;
GVariant *tuple, *rational[2];
GVariantBuilder gvb;
unsigned int i;
(void)probe_group;
switch (key) {
case SR_CONF_SCAN_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
scanopts, ARRAY_SIZE(scanopts), sizeof(int32_t));
break;
case SR_CONF_DEVICE_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
devopts, ARRAY_SIZE(devopts), sizeof(int32_t));
break;
case SR_CONF_BUFFERSIZE:
if (!sdi)
return SR_ERR_ARG;
devc = sdi->priv;
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT64,
devc->profile->buffersizes, 2, sizeof(uint64_t));
break;
case SR_CONF_COUPLING:
*data = g_variant_new_strv(coupling, ARRAY_SIZE(coupling));
break;
case SR_CONF_VDIV:
g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
for (i = 0; i < ARRAY_SIZE(vdivs); i++) {
rational[0] = g_variant_new_uint64(vdivs[i][0]);
rational[1] = g_variant_new_uint64(vdivs[i][1]);
tuple = g_variant_new_tuple(rational, 2);
g_variant_builder_add_value(&gvb, tuple);
}
*data = g_variant_builder_end(&gvb);
break;
case SR_CONF_FILTER:
*data = g_variant_new_strv(filter_targets,
ARRAY_SIZE(filter_targets));
break;
case SR_CONF_TIMEBASE:
g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
for (i = 0; i < ARRAY_SIZE(timebases); i++) {
rational[0] = g_variant_new_uint64(timebases[i][0]);
rational[1] = g_variant_new_uint64(timebases[i][1]);
tuple = g_variant_new_tuple(rational, 2);
g_variant_builder_add_value(&gvb, tuple);
}
*data = g_variant_builder_end(&gvb);
break;
case SR_CONF_TRIGGER_SOURCE:
*data = g_variant_new_strv(trigger_sources,
ARRAY_SIZE(trigger_sources));
break;
default:
return SR_ERR_NA;
}
return SR_OK;
}
static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
GVariant *tuple, *rational[2];
GVariantBuilder gvb;
unsigned int i;
GVariant *gvar;
if (key == SR_CONF_SCAN_OPTIONS) {
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
return SR_OK;
} else if (key == SR_CONF_DEVICE_OPTIONS && !sdi) {
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
drvopts, ARRAY_SIZE(drvopts), sizeof(uint32_t));
return SR_OK;
}
if (!sdi)
return SR_ERR_ARG;
if (!cg) {
switch (key) {
case SR_CONF_DEVICE_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
break;
case SR_CONF_SAMPLERATE:
g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"),
samplerates, ARRAY_SIZE(samplerates),
sizeof(uint64_t));
g_variant_builder_add(&gvb, "{sv}", "samplerates", gvar);
*data = g_variant_builder_end(&gvb);
break;
default:
return SR_ERR_NA;
}
} else {
switch (key) {
case SR_CONF_DEVICE_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
devopts_cg, ARRAY_SIZE(devopts_cg), sizeof(uint32_t));
break;
case SR_CONF_COUPLING:
*data = g_variant_new_strv(coupling, ARRAY_SIZE(coupling));
break;
case SR_CONF_VDIV:
g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
for (i = 0; i < ARRAY_SIZE(vdivs); i++) {
rational[0] = g_variant_new_uint64(vdivs[i][0]);
rational[1] = g_variant_new_uint64(vdivs[i][1]);
tuple = g_variant_new_tuple(rational, 2);
g_variant_builder_add_value(&gvb, tuple);
}
*data = g_variant_builder_end(&gvb);
break;
default:
return SR_ERR_NA;
}
}
return SR_OK;
}
int opt_to_gvar(char *key, char *value, struct sr_config *src)
{
const struct sr_config_info *srci;
double tmp_double, dlow, dhigh;
uint64_t tmp_u64, p, q, low, high;
GVariant *rational[2], *range[2];
gboolean tmp_bool;
int ret;
if (!(srci = sr_config_info_name_get(key))) {
g_critical("Unknown device option '%s'.", (char *) key);
return -1;
}
src->key = srci->key;
if ((value == NULL) &&
(srci->datatype != SR_T_BOOL)) {
g_critical("Option '%s' needs a value.", (char *)key);
return -1;
}
ret = 0;
switch (srci->datatype) {
case SR_T_UINT64:
ret = sr_parse_sizestring(value, &tmp_u64);
if (ret != 0)
break;
src->data = g_variant_new_uint64(tmp_u64);
break;
case SR_T_INT32:
ret = sr_parse_sizestring(value, &tmp_u64);
if (ret != 0)
break;
src->data = g_variant_new_int32(tmp_u64);
break;
case SR_T_STRING:
src->data = g_variant_new_string(value);
break;
case SR_T_BOOL:
if (!value)
tmp_bool = TRUE;
else
tmp_bool = sr_parse_boolstring(value);
src->data = g_variant_new_boolean(tmp_bool);
break;
case SR_T_FLOAT:
tmp_double = strtof(value, NULL);
src->data = g_variant_new_double(tmp_double);
break;
case SR_T_RATIONAL_PERIOD:
if ((ret = sr_parse_period(value, &p, &q)) != SR_OK)
break;
rational[0] = g_variant_new_uint64(p);
rational[1] = g_variant_new_uint64(q);
src->data = g_variant_new_tuple(rational, 2);
break;
case SR_T_RATIONAL_VOLT:
if ((ret = sr_parse_voltage(value, &p, &q)) != SR_OK)
break;
rational[0] = g_variant_new_uint64(p);
rational[1] = g_variant_new_uint64(q);
src->data = g_variant_new_tuple(rational, 2);
break;
case SR_T_UINT64_RANGE:
if (sscanf(value, "%"PRIu64"-%"PRIu64, &low, &high) != 2) {
ret = -1;
break;
} else {
range[0] = g_variant_new_uint64(low);
range[1] = g_variant_new_uint64(high);
src->data = g_variant_new_tuple(range, 2);
}
break;
case SR_T_DOUBLE_RANGE:
if (sscanf(value, "%lf-%lf", &dlow, &dhigh) != 2) {
ret = -1;
break;
} else {
range[0] = g_variant_new_double(dlow);
range[1] = g_variant_new_double(dhigh);
src->data = g_variant_new_tuple(range, 2);
}
break;
default:
ret = -1;
}
return ret;
}
