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