static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi, const struct sr_channel_group *cg) { switch (key) { case SR_CONF_SCAN_OPTIONS: case SR_CONF_DEVICE_OPTIONS: return STD_CONFIG_LIST(key, data, sdi, cg, scanopts, drvopts, devopts); case SR_CONF_SPL_WEIGHT_FREQ: *data = g_variant_new_strv(ARRAY_AND_SIZE(weight_freq)); break; case SR_CONF_SPL_WEIGHT_TIME: *data = g_variant_new_strv(ARRAY_AND_SIZE(weight_time)); break; case SR_CONF_SPL_MEASUREMENT_RANGE: *data = std_gvar_tuple_array(ARRAY_AND_SIZE(meas_ranges)); break; case SR_CONF_DATA_SOURCE: *data = g_variant_new_strv(ARRAY_AND_SIZE(data_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) { GSList *l; switch (key) { case SR_CONF_SCAN_OPTIONS: case SR_CONF_DEVICE_OPTIONS: break; case SR_CONF_SAMPLERATE: case SR_CONF_TRIGGER_SOURCE: case SR_CONF_TRIGGER_SLOPE: case SR_CONF_BUFFERSIZE: if (!sdi || cg) return SR_ERR_NA; break; case SR_CONF_VDIV: case SR_CONF_COUPLING: if (!sdi) return SR_ERR_NA; if (!cg) return SR_ERR_CHANNEL_GROUP; l = g_slist_find(sdi->channel_groups, cg); if (!l) return SR_ERR_ARG; break; default: return SR_ERR_NA; } switch (key) { case SR_CONF_SCAN_OPTIONS: return STD_CONFIG_LIST(key, data, sdi, cg, scanopts, NO_OPTS, NO_OPTS); case SR_CONF_DEVICE_OPTIONS: if (!cg) return STD_CONFIG_LIST(key, data, sdi, cg, NO_OPTS, drvopts, devopts); *data = std_gvar_array_u32(ARRAY_AND_SIZE(devopts_cg)); break; case SR_CONF_SAMPLERATE: *data = std_gvar_samplerates(ARRAY_AND_SIZE(samplerates)); break; case SR_CONF_TRIGGER_SOURCE: *data = g_variant_new_strv(ARRAY_AND_SIZE(trigger_sources)); break; case SR_CONF_TRIGGER_SLOPE: *data = g_variant_new_strv(ARRAY_AND_SIZE(trigger_slopes)); break; case SR_CONF_BUFFERSIZE: *data = std_gvar_array_u64(ARRAY_AND_SIZE(buffersizes)); break; case SR_CONF_VDIV: *data = std_gvar_tuple_array(ARRAY_AND_SIZE(vdivs)); break; case SR_CONF_COUPLING: *data = g_variant_new_strv(ARRAY_AND_SIZE(coupling)); break; } return SR_OK; }
static GVariant * get_root_property(GDBusConnection *connection, const char *sender, const char *object_path, const char *interface_name, const char *property_name, GError **error, XmrMprisPlugin *plugin) { if (g_strcmp0(object_path, MPRIS_OBJECT_NAME) != 0 || g_strcmp0(interface_name, MPRIS_ROOT_INTERFACE) != 0) { g_set_error(error, G_DBUS_ERROR, G_DBUS_ERROR_NOT_SUPPORTED, "Property %s.%s not supported", interface_name, property_name); return NULL; } if (g_strcmp0(property_name, "CanQuit") == 0) { return g_variant_new_boolean(TRUE); } else if(g_strcmp0(property_name, "CanRaise") == 0) { return g_variant_new_boolean(TRUE); } else if(g_strcmp0(property_name, "HasTrackList") == 0) { return g_variant_new_boolean(TRUE); } else if (g_strcmp0(property_name, "Identity") == 0) { return g_variant_new_string("xmradio"); } else if (g_strcmp0(property_name, "SupportedUriSchemes") == 0) { const char *fake_supported_schemes[] = { "http", NULL }; return g_variant_new_strv(fake_supported_schemes, -1); } else if (g_strcmp0(property_name, "SupportedMimeTypes") == 0) { const char *fake_supported_mimetypes[] = { "audio/mpeg", NULL }; return g_variant_new_strv(fake_supported_mimetypes, -1); } g_set_error(error, G_DBUS_ERROR, G_DBUS_ERROR_NOT_SUPPORTED, "Property %s.%s not supported", interface_name, property_name); return NULL; }
static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi, const struct sr_channel_group *cg) { struct sr_channel *ch; GVariant *gvar; GVariantBuilder gvb; (void)sdi; if (key == SR_CONF_SCAN_OPTIONS) { *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32, scanopts, ARRAY_SIZE(scanopts), sizeof(int32_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_INT32, devopts, ARRAY_SIZE(devopts), sizeof(int32_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}", "samplerate-steps", gvar); *data = g_variant_builder_end(&gvb); break; default: return SR_ERR_NA; } } else { ch = cg->channels->data; switch (key) { case SR_CONF_DEVICE_OPTIONS: *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32, devopts_cg, ARRAY_SIZE(devopts_cg), sizeof(int32_t)); break; case SR_CONF_PATTERN_MODE: if (ch->type == SR_CHANNEL_LOGIC) *data = g_variant_new_strv(logic_pattern_str, ARRAY_SIZE(logic_pattern_str)); else if (ch->type == SR_CHANNEL_ANALOG) *data = g_variant_new_strv(analog_pattern_str, ARRAY_SIZE(analog_pattern_str)); else return SR_ERR_BUG; 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, *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 int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi, const struct sr_channel_group *cg) { GVariant *gvar; GVariantBuilder gvb; (void)sdi; (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)); *data = g_variant_new_from_data(G_VARIANT_TYPE("ai"), hwcaps, ARRAY_SIZE(hwcaps)*sizeof(int32_t), TRUE, NULL, NULL); break; case SR_CONF_DEVICE_CONFIGS: // *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32, // hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t)); *data = g_variant_new_from_data(G_VARIANT_TYPE("ai"), hwoptions, ARRAY_SIZE(hwoptions)*sizeof(int32_t), TRUE, NULL, NULL); break; case SR_CONF_DEVICE_SESSIONS: *data = g_variant_new_from_data(G_VARIANT_TYPE("ai"), sessions, ARRAY_SIZE(sessions)*sizeof(int32_t), TRUE, NULL, NULL); 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)); gvar = g_variant_new_from_data(G_VARIANT_TYPE("at"), samplerates, ARRAY_SIZE(samplerates)*sizeof(uint64_t), TRUE, NULL, NULL); g_variant_builder_add(&gvb, "{sv}", "samplerates", gvar); *data = g_variant_builder_end(&gvb); break; case SR_CONF_LIMIT_SAMPLES: g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}")); gvar = g_variant_new_from_data(G_VARIANT_TYPE("at"), samplecounts, ARRAY_SIZE(samplecounts)*sizeof(uint64_t), TRUE, NULL, NULL); g_variant_builder_add(&gvb, "{sv}", "samplecounts", gvar); *data = g_variant_builder_end(&gvb); break; case SR_CONF_PATTERN_MODE: *data = g_variant_new_strv(pattern_strings, ARRAY_SIZE(pattern_strings)); break; case SR_CONF_MAX_HEIGHT: *data = g_variant_new_strv(maxHeights, ARRAY_SIZE(maxHeights)); break; default: return SR_ERR_NA; } return SR_OK; }
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; }
GVariant * get_root_property (GDBusConnection * connection, const char *sender, const char *object_path, const char *interface_name, const char *property_name, GError ** error, SnappyMP * mp) { if (g_strcmp0 (object_path, MPRIS_OBJECT_NAME) != 0 || g_strcmp0 (interface_name, MPRIS_ROOT_INTERFACE) != 0) { g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_NOT_SUPPORTED, "Property %s.%s not supported", interface_name, property_name); return NULL; } if (g_strcmp0 (property_name, "CanQuit") == 0) { return g_variant_new_boolean (FALSE); } else if (g_strcmp0 (property_name, "CanRaise") == 0) { return g_variant_new_boolean (FALSE); } else if (g_strcmp0 (property_name, "HasTrackList") == 0) { return g_variant_new_boolean (FALSE); } else if (g_strcmp0 (property_name, "Identity") == 0) { return g_variant_new_string ("snappy"); } else if (g_strcmp0 (property_name, "DesktopEntry") == 0) { return g_variant_new_string ("snappy"); } else if (g_strcmp0 (property_name, "SupportedUriSchemes") == 0) { /* not planning to support this seriously */ const char *fake_supported_schemes[] = { "file", "http", "cdda", "smb", "sftp", NULL }; return g_variant_new_strv (fake_supported_schemes, -1); } else if (g_strcmp0 (property_name, "SupportedMimeTypes") == 0) { /* nor this */ const char *fake_supported_mimetypes[] = { "video/mpeg", "video/quicktime", "video/x-ms-asf", "video/x-msvideo", "video/ogg", "audio/ogg", "application/annodex", "video/annodex", "application/ogg", "audio/x-vorbis+ogg", "audio/x-flac", "audio/mpeg", "video/x-matroska", "audio/x-matroska", "video/x-theora+ogg", NULL }; return g_variant_new_strv (fake_supported_mimetypes, -1); } g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_NOT_SUPPORTED, "Property %s.%s not supported", interface_name, property_name); return NULL; }
static gboolean vardict_sort_and_insert_pkgs (GVariantDict *dict, const char *key_prefix, GUnixFDList *fd_list, const char *const* pkgs, GError **error) { g_autoptr(GVariant) fd_idxs = NULL; g_autoptr(GPtrArray) repo_pkgs = NULL; if (!rpmostree_sort_pkgs_strv (pkgs, fd_list, &repo_pkgs, &fd_idxs, error)) return FALSE; /* for grep: here we insert install-packages/override-replace-packages */ if (repo_pkgs != NULL && repo_pkgs->len > 0) g_variant_dict_insert_value (dict, glnx_strjoina (key_prefix, "-packages"), g_variant_new_strv ((const char *const*)repo_pkgs->pdata, repo_pkgs->len)); /* for grep: here we insert install-local-packages/override-replace-local-packages */ if (fd_idxs != NULL) g_variant_dict_insert_value (dict, glnx_strjoina (key_prefix, "-local-packages"), fd_idxs); return TRUE; }
static void timer_handler (int sig, siginfo_t *si, void *uc) { if (connect != NULL && si->si_value.sival_ptr == &timerid) { bool status; if (read_keyboard_status (&status) && keyboardEnabled != status) { keyboardEnabled = status; GVariantBuilder props_builder; GVariant *props_changed = NULL; g_variant_builder_init (&props_builder, G_VARIANT_TYPE ("a{sv}")); g_variant_builder_add (&props_builder, "{sv}", "LaptopMode", g_variant_new_boolean (keyboardEnabled)); props_changed= g_variant_new ("(s@a{sv}@as)", KEYBOARDBUS , g_variant_builder_end(&props_builder), g_variant_new_strv (NULL, 0)); g_dbus_connection_emit_signal (connect, NULL, KEYBOARDPATH, "org.freedesktop.DBus.Properties", "PropertiesChanged", props_changed, NULL); keyboard__set_laptop_mode (exported_key_object, status); } } }
static void append_key (GVariantBuilder *builder, MetaTree *tree, const char *path, const char *key) { MetaKeyType keytype; char *str; char **strv; keytype = meta_tree_lookup_key_type (tree, path, key); if (keytype == META_KEY_TYPE_STRING) { str = meta_tree_lookup_string (tree, path, key); g_variant_builder_add (builder, "{sv}", key, g_variant_new_string (str)); g_free (str); } else if (keytype == META_KEY_TYPE_STRINGV) { strv = meta_tree_lookup_stringv (tree, path, key); g_variant_builder_add (builder, "{sv}", key, g_variant_new_strv ((const gchar * const *) strv, -1)); g_strfreev (strv); } }
static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi, const struct sr_probe_group *probe_group) { GVariant *gvar; GVariantBuilder gvb; (void)sdi; (void)probe_group; 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: 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}", "samplerate-steps", gvar); *data = g_variant_builder_end(&gvb); break; case SR_CONF_PATTERN_MODE: *data = g_variant_new_strv(pattern_strings, ARRAY_SIZE(pattern_strings)); 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) { (void)cg; 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: if (!sdi) *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32, drvopts, ARRAY_SIZE(drvopts), sizeof(uint32_t)); else *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32, devopts, ARRAY_SIZE(devopts), sizeof(uint32_t)); 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 GVariant * parse_res_txt (guchar *answer, guchar *end, guchar **p) { GVariant *record; GPtrArray *array; guchar *at = *p; gsize len; array = g_ptr_array_new_with_free_func (g_free); while (at < end) { len = *(at++); if (len > at - end) break; g_ptr_array_add (array, g_strndup ((gchar *)at, len)); at += len; } *p = at; record = g_variant_new ("(@as)", g_variant_new_strv ((const gchar **)array->pdata, array->len)); g_ptr_array_free (array, TRUE); return record; }
static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi, const struct sr_channel_group *cg) { GVariant *gvar; GVariantBuilder gvb; (void)sdi; (void)cg; 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_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_TRIGGER_SOURCE: *data = g_variant_new_strv(trigger_source_names, ARRAY_SIZE(trigger_source_names)); break; case SR_CONF_TRIGGER_SLOPE: case SR_CONF_CLOCK_EDGE: *data = g_variant_new_strv(signal_edge_names, ARRAY_SIZE(signal_edge_names)); break; default: return SR_ERR_NA; } return SR_OK; }
static GVariant * _root_property_cb (GDBusConnection *connection, const gchar *sender, const gchar *object_path, const gchar *interface_name, const gchar *property_name, GError **error, MexMprisPlugin *self) { MexMprisPluginPrivate *priv = MEX_MPRIS_PLUGIN (self)->priv; if (g_strcmp0 (property_name, "SupportedUriSchemes") == 0) { const char *supported_schemes[] = { "file", "http", "cdda", "smb", "sftp", "ftp", NULL }; return g_variant_new_strv (supported_schemes, -1); } if (g_strcmp0 (property_name, "SupportedMimeTypes") == 0) return g_variant_new_strv ((const gchar**)priv->mimes_supported, -1); if (g_strcmp0 (property_name, "CanQuit") == 0 || g_strcmp0 (property_name, "CanRaise") == 0 || g_strcmp0 (property_name, "HasTrackList") == 0) return g_variant_new_boolean (FALSE); if (g_strcmp0 (property_name, "DesktopEntry") == 0) return g_variant_new_string ("media-explorer"); if (g_strcmp0 (property_name, "Identity") == 0) return g_variant_new_string ("Media Explorer"); g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_NOT_SUPPORTED, "Property %s.%s not supported", interface_name, property_name); return NULL; }
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 GVariant * setup_get_property (GDBusConnection *connection, const gchar *sender, const gchar *object_path, const gchar *interface_name, const gchar *property_name, GError **error, gpointer user_data) { const gchar *mechanisms[] = { "passwd1", NULL, }; g_return_val_if_fail (g_str_equal (property_name, "Mechanisms"), NULL); return g_variant_new_strv (mechanisms, -1); }
/** * yts_service_send_list: * @self: object on which to invoke this method. * @texts: messages to send to the remote service. * @length: number of elements in @texts, or -1 if @texts is %NULL-terminated. * * Send a list of text messages to remote service @self. * * Since: 0.3 */ void yts_service_send_list (YtsService *self, char const *const *texts, int length) { YtsMetadata *message; g_return_if_fail (YTS_IS_SERVICE (self)); message = create_message ("list", g_variant_new_strv (texts, length)); yts_service_emitter_send_message (YTS_SERVICE_EMITTER (self), message); g_object_unref (message); }
GVariant * vino_set_authtype (const GValue *value, const GVariantType *type, gpointer user_data) { const gchar *authtype; if (g_value_get_boolean (value)) authtype = "vnc"; else authtype = "none"; return g_variant_new_strv (&authtype, 1); }
static void setup_prepare_passwd1 (GVariant *parameters, GDBusMethodInvocation *invocation) { const gchar *mechanism; GPtrArray *names; GPtrArray *groups; GVariant *result = NULL; g_variant_get (parameters, "(&s)", &mechanism); names = g_ptr_array_new_with_free_func (g_free); groups = g_ptr_array_new_with_free_func (g_free); if (!g_str_equal (mechanism, "passwd1")) { g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_NOT_SUPPORTED, _("Unsupported setup mechanism: %s"), mechanism); } else if (fgetpwent_callback (add_name_to_array, names) && fgetgrent_callback (add_group_to_array, groups)) { /* We don't need to prepare anything */ result = g_variant_new ("(@as@as)", g_variant_new_strv ((const gchar * const *)names->pdata, names->len), g_variant_new_strv ((const gchar * const *)groups->pdata, groups->len)); g_dbus_method_invocation_return_value (invocation, g_variant_new ("(v)", result)); } else { g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_FAILED, _("Couldn't list users")); } g_ptr_array_free (groups, TRUE); g_ptr_array_free (names, TRUE); }
static GVariant * variant_for_metadata(const char *value, gboolean as_list) { if (as_list) { const char *strv[] = { value, NULL }; return g_variant_new_strv(strv, -1); } else { return g_variant_new_string(value); } }
static GVariant * parse_dns_txt (DNS_RECORD *rec) { GVariant *record; GPtrArray *array; DWORD i; array = g_ptr_array_new (); for (i = 0; i < rec->Data.TXT.dwStringCount; i++) g_ptr_array_add (array, rec->Data.TXT.pStringArray[i]); record = g_variant_new ("(@as)", g_variant_new_strv ((const gchar **)array->pdata, array->len)); g_ptr_array_free (array, TRUE); return record; }
static GVariant * get_repo_pull_options (const gchar *url_override, const gchar *ref) { g_auto(GVariantBuilder) builder; g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}")); if (url_override != NULL) g_variant_builder_add (&builder, "{s@v}", "override-url", g_variant_new_variant (g_variant_new_string (url_override))); g_variant_builder_add (&builder, "{s@v}", "flags", g_variant_new_variant (g_variant_new_int32 (OSTREE_REPO_PULL_FLAGS_COMMIT_ONLY))); g_variant_builder_add (&builder, "{s@v}", "refs", g_variant_new_variant (g_variant_new_strv (&ref, 1))); return g_variant_ref_sink (g_variant_builder_end (&builder)); };
gboolean connman_service_set_nameservers(connman_service_t *service, GStrv dns) { if(NULL == service || NULL == dns) return FALSE; GError *error = NULL; connman_interface_service_call_set_property_sync(service->remote, "Nameservers.Configuration", g_variant_new_variant(g_variant_new_strv((const gchar * const*)dns, g_strv_length(dns))), NULL, &error); if (error) { WCA_LOG_CRITICAL("Error: %s", error->message); g_error_free(error); return FALSE; } return TRUE; }
static GVariant * switch_tracker_set_mapping (const GValue *value, const GVariantType *expected_type, gpointer user_data) { Place *place = user_data; GPtrArray *new_values; gboolean remove; GVariant *variant; remove = !g_value_get_boolean (value); new_values = place_get_new_settings_values (place, remove); variant = g_variant_new_strv ((const gchar **) new_values->pdata, -1); g_ptr_array_unref (new_values); return variant; }
static GVariant * switch_settings_mapping_set_generic (const GValue *value, const GVariantType *expected_type, GtkWidget *row, gboolean default_enabled) { CcSearchPanel *self = g_object_get_data (G_OBJECT (row), "self"); GAppInfo *app_info = g_object_get_data (G_OBJECT (row), "app-info"); gchar **apps; GPtrArray *new_apps; gint idx; gboolean remove, found; GVariant *variant; remove = !!g_value_get_boolean (value) == !!default_enabled; found = FALSE; new_apps = g_ptr_array_new_with_free_func (g_free); apps = g_settings_get_strv (self->priv->search_settings, default_enabled ? "disabled" : "enabled"); for (idx = 0; apps[idx] != NULL; idx++) { if (g_strcmp0 (apps[idx], g_app_info_get_id (app_info)) == 0) { found = TRUE; if (remove) continue; } g_ptr_array_add (new_apps, g_strdup (apps[idx])); } if (!found && !remove) g_ptr_array_add (new_apps, g_strdup (g_app_info_get_id (app_info))); g_ptr_array_add (new_apps, NULL); variant = g_variant_new_strv ((const gchar **) new_apps->pdata, -1); g_ptr_array_unref (new_apps); g_strfreev (apps); return variant; }
GVariant * CAGattCharacteristicGetProperties( GattCharacteristic1 * characteristic) { /** * Create a variant containing the @c GattCharacteristic1 * properties, of the form @c a{sa{sv}}. * * @note We don't care about the "Value" property here since it is * automatically made available by BlueZ on the client * side. * * @todo Should we care about "Notifying" property here? */ /* Populate the property table, and create the variant to be embedded in the results of the org.freedesktop.Dbus.ObjectManager.GetManagedObjects() method call. */ CADBusSkeletonProperty const properties[] = { { "UUID", g_variant_new_string( gatt_characteristic1_get_uuid(characteristic)) }, { "Service", g_variant_new_object_path( gatt_characteristic1_get_service(characteristic)) }, { "Flags", g_variant_new_strv( gatt_characteristic1_get_flags(characteristic), -1) }, { "Descriptors", g_variant_new_objv( gatt_characteristic1_get_descriptors(characteristic), -1) } }; return CAMakePropertyDictionary( BLUEZ_GATT_CHARACTERISTIC_INTERFACE, properties, sizeof(properties) / sizeof(properties[0])); }
static GVariant * ip4_address_labels_get (NMSetting *setting, NMConnection *connection, const char *property) { NMSettingIPConfig *s_ip = NM_SETTING_IP_CONFIG (setting); gboolean have_labels = FALSE; GPtrArray *labels; GVariant *ret; int num_addrs, i; num_addrs = nm_setting_ip_config_get_num_addresses (s_ip); for (i = 0; i < num_addrs; i++) { NMIPAddress *addr = nm_setting_ip_config_get_address (s_ip, i); GVariant *label = nm_ip_address_get_attribute (addr, "label"); if (label) { have_labels = TRUE; break; } } if (!have_labels) return NULL; labels = g_ptr_array_sized_new (num_addrs); for (i = 0; i < num_addrs; i++) { NMIPAddress *addr = nm_setting_ip_config_get_address (s_ip, i); GVariant *label = nm_ip_address_get_attribute (addr, "label"); g_ptr_array_add (labels, (char *) (label ? g_variant_get_string (label, NULL) : "")); } ret = g_variant_new_strv ((const char * const *) labels->pdata, labels->len); g_ptr_array_unref (labels); return ret; }
GVariant * CAGattDescriptorGetProperties(GattDescriptor1 * descriptor) { /** * Create a variant containing the @c GattDescriptor1 properties, * of the form @c a{sa{sv}}. * * @note We don't care about the "Value" property here since it is * automatically made available by BlueZ on the client * side. */ /* Populate the property table, and create the variant to be embedded in the results of the org.freedesktop.Dbus.ObjectManager.GetManagedObjects() method call. */ CADBusSkeletonProperty const properties[] = { { "UUID", g_variant_new_string( gatt_descriptor1_get_uuid(descriptor)) }, { "Characteristic", g_variant_new_object_path( gatt_descriptor1_get_characteristic(descriptor)) }, { "Flags", g_variant_new_strv( gatt_descriptor1_get_flags(descriptor), -1) } }; return CAMakePropertyDictionary( BLUEZ_GATT_DESCRIPTOR_INTERFACE, properties, sizeof(properties) / sizeof(properties[0])); }