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