static void onPropertiesChanged(GDBusProxy *proxy,
GVariant *changed_properties,
const gchar* const *invalidated_properties,
gpointer pp)
{
if (g_variant_n_children(changed_properties) > 0) {
GVariantIter *iter;
gchar *key;
GVariant *value;
debug(" *** Properties Changed:\n");
g_variant_get(changed_properties, "a{sv}", &iter);
while (g_variant_iter_loop (iter, "{&sv}", &key, &value)) {
gchar *value_str;
value_str = g_variant_print(value, TRUE);
g_print(" %s -> %s\n", key, value_str);
g_free(value_str);
if (strncmp(key, "Metadata",8) == 0) {
trackChanged(value);
} else if (strcmp(key, "PlaybackStatus") == 0) {
playbackChanged(g_variant_dup_string(value, NULL));
} else if (strcmp(key, "LoopStatus") == 0) {
loopChanged(g_variant_dup_string(value, NULL));
} else if (strcmp(key, "Shuffle") == 0) {
shuffleChanged(g_variant_get_boolean(value));
} else if (strcmp(key, "Position") == 0) {
positionChanged(g_variant_get_int64(value));
} else if (strcmp(key, "Volume") == 0) {
volumeChanged(g_variant_get_double(value));
}
}
g_variant_iter_free (iter);
}
}
static OlLyricSourceCandidate *
ol_lyric_source_candidate_new_with_variant (GVariant *dict)
{
ol_log_func ();
OlLyricSourceCandidate *candidate = NULL;
GVariantIter *dictiter = NULL;
gchar *key = NULL;
gchar *title, *artist, *album, *comment, *sourceid;
GVariant *downloadinfo = NULL;
GVariant *value = NULL;
title = artist = album = comment = sourceid = NULL;
g_variant_get (dict, "a{sv}", &dictiter);
while (g_variant_iter_loop (dictiter, "{sv}", &key, &value))
{
if (strcmp (key, "title") == 0 && title == NULL)
{
title = g_variant_dup_string (value, NULL);
}
else if (strcmp (key, "artist") == 0 && artist == NULL)
{
artist = g_variant_dup_string (value, NULL);
}
else if (strcmp (key, "album") == 0 && album == NULL)
{
album = g_variant_dup_string (value, NULL);
}
else if (strcmp (key, "comment") == 0 && comment == NULL)
{
comment = g_variant_dup_string (value, NULL);
}
else if (strcmp (key, "sourceid") == 0 && sourceid == NULL)
{
sourceid = g_variant_dup_string (value, NULL);
}
else if (strcmp (key, "downloadinfo") == 0 && downloadinfo == NULL)
{
downloadinfo = g_variant_ref (value);
}
else
{
ol_errorf ("Unknown candidate key: %s\n", key);
}
}
g_variant_iter_free (dictiter);
candidate = ol_lyric_source_candidate_new (title,
artist,
album,
comment,
sourceid,
downloadinfo);
g_free (title);
g_free (artist);
g_free (album);
g_free (comment);
g_free (sourceid);
g_variant_unref (downloadinfo);
return candidate;
}
ConnmanService *connman_service_new(GVariant *variant)
{
ConnmanService *service = g_object_new(CONNMAN_TYPE_SERVICE, NULL);
GVariant *child = g_variant_get_child_value(variant, 0);
GVariant *attrs;
gsize i;
service->object_path = g_variant_dup_string(child, NULL);
attrs = g_variant_get_child_value(variant, 1);
for (i = 0; i < g_variant_n_children(attrs); i++)
{
GVariant *attr = g_variant_get_child_value(attrs, i);
GVariant *key_v = g_variant_get_child_value(attr, 0);
GVariant *val_v = g_variant_get_child_value(attr, 1);
GVariant *val = g_variant_get_variant(val_v);
const gchar *key = g_variant_get_string(key_v, NULL);
if (g_str_equal(key, "Name"))
service->name = g_variant_dup_string(val, NULL);
if (g_str_equal(key, "Type"))
{
const gchar *v = g_variant_get_string(val, NULL);
if (g_str_equal(v, "wifi"))
service->type = CONNMAN_SERVICE_TYPE_WIFI;
if (g_str_equal(v, "ethernet"))
service->type = CONNMAN_SERVICE_TYPE_ETHERNET;
}
if (g_str_equal(key, "LoginRequired"))
service->login_required = g_variant_get_boolean(val);
if (g_str_equal(key, "PassphraseRequired"))
service->passphrase_required = g_variant_get_boolean(val);
if (g_str_equal(key, "AutoConnect"))
service->auto_connect = g_variant_get_boolean(val);
if (g_str_equal(key, "Immutable"))
service->immutable = g_variant_get_boolean(val);
if (g_str_equal(key, "Favorite"))
service->favorite = g_variant_get_boolean(val);
if (g_str_equal(key, "Strength"))
service->strength = g_variant_get_byte(val);
}
g_message("new service %p: '%s' (%d)", service, service->name, service->type);
return service;
}
static void
photos_create_collection_job_query_executed (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
PhotosCreateCollectionJob *self = PHOTOS_CREATE_COLLECTION_JOB (user_data);
TrackerSparqlConnection *connection = TRACKER_SPARQL_CONNECTION (source_object);
GError *error;
GVariant *variant;
GVariant *child;
gchar *key = NULL;
gchar *val = NULL;
error = NULL;
variant = tracker_sparql_connection_update_blank_finish (connection, res, &error);
if (error != NULL)
{
g_warning ("Unable to create collection: %s", error->message);
g_error_free (error);
goto out;
}
child = g_variant_get_child_value (variant, 0); /* variant is now aa{ss} */
g_variant_unref (variant);
variant = child;
child = g_variant_get_child_value (variant, 0); /* variant is now s{ss} */
g_variant_unref (variant);
variant = child;
child = g_variant_get_child_value (variant, 0); /* variant is now {ss} */
g_variant_unref (variant);
variant = child;
child = g_variant_get_child_value (variant, 0);
key = g_variant_dup_string (child, NULL);
g_variant_unref (child);
child = g_variant_get_child_value (variant, 1);
val = g_variant_dup_string (child, NULL);
g_variant_unref (child);
g_variant_unref (variant);
if (g_strcmp0 (key, "res") == 0)
self->created_urn = val;
out:
if (self->callback != NULL)
(*self->callback) (self->created_urn, self->user_data);
self->created_urn = NULL;
g_free (val);
g_free (key);
}
/* --- genlist callbacks --- */
static char *
gl_text_get(void *data, Evas_Object * obj, const char *part)
{
(void) obj;
GHashTable *entry = (GHashTable *) data;
GVariant *val;
g_debug("gl_text_get: %s", part);
if (!strcmp(part, "elm.text")) {
val = g_hash_table_lookup(entry, "Name");
if (val) {
return g_variant_dup_string(val, NULL);
}
return strdup("");
}
if (!strcmp(part, "elm.text.sub")) {
val = g_hash_table_lookup(entry, "Peer");
if (val) {
return g_variant_dup_string(val, NULL);
}
return strdup(CONTACT_PHONE_UNDEFINED_STRING);
}
if (!strcmp(part, "elm.text.2")) {
val = g_hash_table_lookup(entry, "Timestamp");
if (val) {
return common_utils_timestamp_to_date
(g_variant_get_int32(val));
}
}
if (!strcmp(part, "elm.text.sub.2")) {
val = g_hash_table_lookup(entry, "Duration");
if (val) {
float duration = strtof(g_variant_get_string(val, NULL), NULL);
int h = duration / 3600;
int m = duration / 60 - h * 60;
int s = duration - h * 3600 - m * 60;
char durstr[10];
if (h > 0) {
snprintf(durstr, 10, "%02d:%02d:%02d", h, m, s);
}
else {
snprintf(durstr, 10, "%02d:%02d", m, s);
}
return strdup(durstr);
}
return strdup("00:00");
}
return strdup("");
}
void connman_service_update_properties(connman_service_t *service, GVariant *properties)
{
if(NULL == service || NULL == properties)
return;
gsize i;
for (i = 0; i < g_variant_n_children(properties); i++)
{
GVariant *property = g_variant_get_child_value(properties, i);
GVariant *key_v = g_variant_get_child_value(property, 0);
GVariant *val_v = g_variant_get_child_value(property, 1);
GVariant *val = g_variant_get_variant(val_v);
const gchar *key = g_variant_get_string(key_v, NULL);
if (g_str_equal(key, "Name"))
{
g_free(service->name);
service->name = g_variant_dup_string(val, NULL);
}
else if (g_str_equal(key, "Type"))
{
const gchar *v = g_variant_get_string(val, NULL);
if (g_str_equal(v, "wifi"))
service->type = CONNMAN_SERVICE_TYPE_WIFI;
if (g_str_equal(v, "ethernet"))
service->type = CONNMAN_SERVICE_TYPE_ETHERNET;
}
else if (g_str_equal(key, "State"))
{
g_free(service->state);
service->state = g_variant_dup_string(val, NULL);
// Only a hidden service gets added as a new service with "association" state
if(g_str_equal(service->state, "association"))
service->hidden = TRUE;
}
else if (g_str_equal(key, "Strength"))
service->strength = g_variant_get_byte(val);
else if(g_str_equal(key, "Security"))
{
g_strfreev(service->security);
service->security = g_variant_dup_strv(val, NULL);
}
else if (g_str_equal(key, "AutoConnect"))
service->auto_connect = g_variant_get_boolean(val);
else if (g_str_equal(key, "Immutable"))
service->immutable = g_variant_get_boolean(val);
else if (g_str_equal(key, "Favorite"))
service->favorite = g_variant_get_boolean(val);
}
}
static void
photos_create_collection_job_query_executed (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
GTask *task = G_TASK (user_data);
TrackerSparqlConnection *connection = TRACKER_SPARQL_CONNECTION (source_object);
GError *error;
GVariant *variant;
GVariant *child;
gchar *key = NULL;
gchar *val = NULL;
error = NULL;
variant = tracker_sparql_connection_update_blank_finish (connection, res, &error);
if (error != NULL)
{
g_task_return_error (task, error);
return;
}
child = g_variant_get_child_value (variant, 0); /* variant is now aa{ss} */
g_variant_unref (variant);
variant = child;
child = g_variant_get_child_value (variant, 0); /* variant is now s{ss} */
g_variant_unref (variant);
variant = child;
child = g_variant_get_child_value (variant, 0); /* variant is now {ss} */
g_variant_unref (variant);
variant = child;
child = g_variant_get_child_value (variant, 0);
key = g_variant_dup_string (child, NULL);
g_variant_unref (child);
child = g_variant_get_child_value (variant, 1);
val = g_variant_dup_string (child, NULL);
g_variant_unref (child);
g_variant_unref (variant);
if (g_strcmp0 (key, "res") == 0)
g_task_return_pointer (task, g_strdup (val), g_free);
else
g_task_return_new_error (task, PHOTOS_ERROR, 0, "Failed to parse GVariant");
g_free (val);
g_free (key);
}
static void _dbus_steadyflow_iapp_service_add_file (SteadyflowIAppService* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
GError* error = NULL;
GVariantIter _arguments_iter;
gchar* url = NULL;
GVariant* _tmp0_;
GDBusMessage* _reply_message;
GVariant* _reply;
GVariantBuilder _reply_builder;
g_variant_iter_init (&_arguments_iter, parameters);
_tmp0_ = g_variant_iter_next_value (&_arguments_iter);
url = g_variant_dup_string (_tmp0_, NULL);
g_variant_unref (_tmp0_);
steadyflow_iapp_service_add_file (self, url, &error);
if (error) {
g_dbus_method_invocation_return_gerror (invocation, error);
return;
}
_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
_reply = g_variant_builder_end (&_reply_builder);
g_dbus_message_set_body (_reply_message, _reply);
_g_free0 (url);
g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
g_object_unref (invocation);
g_object_unref (_reply_message);
}
static gboolean handle_set_property (GDBusConnection *connection,
const gchar *sender,
const gchar *object_path,
const gchar *interface_name,
const gchar *property_name,
GVariant *value,
GError **error,
gpointer user_data)
{
printf("set property: '%s'\n", property_name);
if (!g_strcmp0(property_name, "Title")) {
if (g_strcmp0(_global_title, g_variant_get_string (value, NULL))) {
GVariantBuilder *builder;
GError *local_error;
g_free(_global_title);
_global_title = g_variant_dup_string(value, NULL);
local_error = NULL;
builder = g_variant_builder_new(G_VARIANT_TYPE_ARRAY);
g_variant_builder_add
(builder, "{sv}", "Title",
g_variant_new_string(_global_title));
g_dbus_connection_emit_signal
(connection, NULL, object_path,
"org.freedesktop.DBus.Properties",
"PropertiesChanged",
g_variant_new("(sa{sv}as)", interface_name,
builder, NULL),
&local_error);
g_assert_no_error (local_error);
}
}
return *error == NULL;
}
static void _dbus_geany_dbus_application_open_documents (GeanyDBusApplication* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
GError* error;
char** filenames = NULL;
int filenames_length1;
GVariant* _tmp1_;
char** _tmp2_;
int _tmp2__length;
int _tmp2__size;
int _tmp2__length1;
GVariantIter _tmp3_;
GVariant* _tmp4_;
GVariantIter _arguments_iter;
GVariant* _reply;
GVariantBuilder _reply_builder;
error = NULL;
g_variant_iter_init (&_arguments_iter, parameters);
filenames_length1 = 0;
_tmp1_ = g_variant_iter_next_value (&_arguments_iter);
_tmp2_ = g_new (char*, 5);
_tmp2__length = 0;
_tmp2__size = 4;
_tmp2__length1 = 0;
g_variant_iter_init (&_tmp3_, _tmp1_);
for (; _tmp4_ = g_variant_iter_next_value (&_tmp3_); _tmp2__length1++) {
if (_tmp2__size == _tmp2__length) {
_tmp2__size = 2 * _tmp2__size;
_tmp2_ = g_renew (char*, _tmp2_, _tmp2__size + 1);
}
_tmp2_[_tmp2__length++] = g_variant_dup_string (_tmp4_, NULL);
g_variant_unref (_tmp4_);
}
gchar *gstd_pipeline_element_get_property_string(GDBusProxy *pipeline_proxy,
const gchar *element,
const gchar *name)
{
GError *error = NULL;
GVariant *variant = NULL;
gchar *property_string = NULL;
variant = g_dbus_proxy_call_sync(pipeline_proxy,
"ElementGetPropertyString",
g_variant_new("(ss)", element, name),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (error) {
g_printerr("g_dbus_proxy_new_for_bus_sync failed: %s\n", error->message);
return NULL;
}
if (!g_strcmp0(g_variant_get_type_string(variant), "(sb)")) {
GVariant *string_variant = g_variant_get_child_value(variant, 0);
property_string = g_variant_dup_string(string_variant, NULL);
}
g_variant_unref(variant);
return property_string;
}
static void
create_context_for_device (NMDevice *nm_device)
{
GError *error = NULL;
guint port;
GVariant *value;
char *iface;
char *ssid = NULL;
g_object_get (nm_device->manager,
"port", &port,
NULL);
value = g_dbus_proxy_get_cached_property (nm_device->proxy,
"Interface");
if (G_UNLIKELY (value == NULL))
return;
if (G_UNLIKELY (!g_variant_is_of_type (value, G_VARIANT_TYPE_STRING))) {
g_variant_unref (value);
return;
}
iface = g_variant_dup_string (value, NULL);
g_variant_unref (value);
if (nm_device->ap_proxy != NULL) {
value = g_dbus_proxy_get_cached_property (nm_device->ap_proxy,
"Ssid");
if (G_LIKELY (value != NULL)) {
ssid = g_strndup (g_variant_get_data (value),
g_variant_get_size (value));
g_variant_unref (value);
}
}
nm_device->context = g_initable_new (GUPNP_TYPE_CONTEXT,
NULL,
&error,
"interface", iface,
"network", ssid,
"port", port,
NULL);
g_free (iface);
g_free (ssid);
if (error) {
g_warning ("Error creating GUPnP context: %s\n",
error->message);
g_error_free (error);
return;
}
g_signal_emit_by_name (nm_device->manager,
"context-available",
nm_device->context);
}
gchar* dbus_get_string_property(GDBusProxy *proxy, gchar * property) {
GVariant* var;
gchar* rv;
var = g_dbus_proxy_get_cached_property(proxy, property);
rv = g_variant_dup_string(var, 0);
g_variant_unref(var);
return rv;
}
// webkit_web_extension_initialize_with_user_data initializes the web extension
//
// The profile name should be passed as the user data.
G_MODULE_EXPORT void
webkit_web_extension_initialize_with_user_data(WebKitWebExtension *extension,
GVariant *data)
{
gchar *profile = g_variant_dup_string(data, NULL);
g_signal_connect(extension, "page-created",
G_CALLBACK(web_page_created_callback), profile);
}
void updatePlaybackProperty() {
GVariant * playback = updateProperty(mpris_data->player, "PlaybackStatus");
if (playback == NULL) {
return;
}
playbackChanged(g_variant_dup_string(playback, NULL));
g_variant_unref(playback);
}
MMLocationGpsRaw *
mm_location_gps_raw_new_from_dictionary (GVariant *dictionary,
GError **error)
{
GError *inner_error = NULL;
MMLocationGpsRaw *self;
GVariantIter iter;
gchar *key;
GVariant *value;
self = mm_location_gps_raw_new ();
if (!dictionary)
return self;
if (!g_variant_is_of_type (dictionary, G_VARIANT_TYPE ("a{sv}"))) {
g_set_error (error,
MM_CORE_ERROR,
MM_CORE_ERROR_INVALID_ARGS,
"Cannot create GPS RAW location from dictionary: "
"invalid variant type received");
g_object_unref (self);
return NULL;
}
g_variant_iter_init (&iter, dictionary);
while (!inner_error &&
g_variant_iter_next (&iter, "{sv}", &key, &value)) {
if (g_str_equal (key, PROPERTY_UTC_TIME))
self->priv->utc_time = g_variant_dup_string (value, NULL);
else if (g_str_equal (key, PROPERTY_LONGITUDE))
self->priv->longitude = g_variant_get_double (value);
else if (g_str_equal (key, PROPERTY_LATITUDE))
self->priv->latitude = g_variant_get_double (value);
else if (g_str_equal (key, PROPERTY_ALTITUDE))
self->priv->altitude = g_variant_get_double (value);
g_free (key);
g_variant_unref (value);
}
/* If any of the mandatory parameters is missing, cleanup */
if (!self->priv->utc_time ||
self->priv->longitude == MM_LOCATION_LONGITUDE_UNKNOWN ||
self->priv->latitude == MM_LOCATION_LATITUDE_UNKNOWN) {
g_set_error (error,
MM_CORE_ERROR,
MM_CORE_ERROR_INVALID_ARGS,
"Cannot create GPS RAW location from dictionary: "
"mandatory parameters missing "
"(utc-time: %s, longitude: %s, latitude: %s)",
self->priv->utc_time ? "yes" : "missing",
(self->priv->longitude != MM_LOCATION_LONGITUDE_UNKNOWN) ? "yes" : "missing",
(self->priv->latitude != MM_LOCATION_LATITUDE_UNKNOWN) ? "yes" : "missing");
g_clear_object (&self);
}
return self;
}
static gboolean
handle_set_property (GDBusConnection *connection,
const gchar *sender,
const gchar *object_path,
const gchar *interface_name,
const gchar *property_name,
GVariant *value,
GError **error,
gpointer user_data)
{
if (g_strcmp0 (property_name, "Title") == 0)
{
if (g_strcmp0 (_global_title, g_variant_get_string (value, NULL)) != 0)
{
GVariantBuilder *builder;
GError *local_error;
g_free (_global_title);
_global_title = g_variant_dup_string (value, NULL);
local_error = NULL;
builder = g_variant_builder_new (G_VARIANT_TYPE_ARRAY);
g_variant_builder_add (builder,
"{sv}",
"Title",
g_variant_new_string (_global_title));
g_dbus_connection_emit_signal (connection,
NULL,
object_path,
"org.freedesktop.DBus.Properties",
"PropertiesChanged",
g_variant_new ("(sa{sv}as)",
interface_name,
builder,
NULL),
&local_error);
g_assert_no_error (local_error);
}
}
else if (g_strcmp0 (property_name, "ReadingAlwaysThrowsError") == 0)
{
/* do nothing - they can't read it after all! */
}
else if (g_strcmp0 (property_name, "WritingAlwaysThrowsError") == 0)
{
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_FAILED,
"Hello AGAIN %s. I thought I said writing this property "
"always results in an error. kthxbye",
sender);
}
return *error == NULL;
}
// If kwalletd isn't running: try to start it
static gboolean start_kwallet(backend_kwallet_context_t *context)
{
GError *error = NULL;
// Sadly kwalletd doesn't use DBUS activation, so we have to make a call to
// klauncher to start it.
/*
* signature:
*
* in s serviceName,
* in as urls,
* in as envs,
* in s startup_id,
* in b blind,
*
* out i arg_0,
* out s dbusServiceName,
* out s error,
* out i pid
*/
GVariant *ret = g_dbus_connection_call_sync(context->connection,
klauncher_service_name,
klauncher_path,
klauncher_interface,
"start_service_by_desktop_name",
g_variant_new ("(sasassb)", "kwalletd", NULL, NULL, "", FALSE),
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if(check_error(error))
{
g_variant_unref(ret);
return FALSE;
}
GVariant *child = g_variant_get_child_value(ret, 2);
gchar *error_string = g_variant_dup_string(child, NULL);
g_variant_unref(child);
g_variant_unref(ret);
if(error_string && error_string[0] != '\0')
{
dt_print(DT_DEBUG_PWSTORAGE,"[pwstorage_kwallet] ERROR: error launching kwalletd: %s\n", error_string);
g_free(error_string);
return FALSE;
}
g_free(error_string);
return TRUE;
}
static void
property_changed_cb(ConnmanInterfaceService *proxy, gchar * property, GVariant *v,
connman_service_t *service)
{
/* Invoke function pointers only for state changed */
if(g_str_equal(property, "State") == FALSE)
return;
g_free(service->state);
service->state = g_variant_dup_string(g_variant_get_variant(v), NULL);
if(NULL != service->handle_state_change_fn)
(service->handle_state_change_fn)((gpointer)service, service->state);
}
// Initialize the connection to KWallet
static gboolean init_kwallet(backend_kwallet_context_t *context)
{
GError *error = NULL;
// Make a proxy to KWallet.
if(context->proxy) g_object_unref(context->proxy);
context->proxy = g_dbus_proxy_new_sync(context->connection, G_DBUS_PROXY_FLAGS_NONE, NULL,
kwallet_service_name, kwallet_path, kwallet_interface, NULL, &error);
if(check_error(error))
{
context->proxy = NULL;
return FALSE;
}
// Check KWallet is enabled.
GVariant *ret
= g_dbus_proxy_call_sync(context->proxy, "isEnabled", NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
if(!ret) return FALSE;
GVariant *child = g_variant_get_child_value(ret, 0);
gboolean is_enabled = g_variant_get_boolean(child);
g_variant_unref(child);
g_variant_unref(ret);
if(check_error(error) || !is_enabled) return FALSE;
// Get the wallet name.
g_free(context->wallet_name);
ret = g_dbus_proxy_call_sync(context->proxy, "networkWallet", NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL,
&error);
child = g_variant_get_child_value(ret, 0);
context->wallet_name = g_variant_dup_string(child, NULL);
g_variant_unref(child);
g_variant_unref(ret);
if(check_error(error) || !context->wallet_name)
{
context->wallet_name = NULL; // yes, it's stupid. go figure.
return FALSE;
}
return TRUE;
}
gchar *get_connection(const gchar *obj, GError **error){
GDBusProxy *proxy = NULL;
proxy = g_dbus_proxy_new_for_bus_sync(
G_BUS_TYPE_SESSION,
G_DBUS_PROXY_FLAGS_NONE,
NULL,
"org.freedesktop.Telepathy.AccountManager",
obj,
"org.freedesktop.Telepathy.Account",
NULL,
error);
if (proxy == NULL) return NULL;
GVariant *res = g_dbus_proxy_get_cached_property(proxy, "Connection");
gchar *ret = g_variant_dup_string(res, NULL);
g_object_unref(proxy);
return ret;
}
static char *
systemd_unit_property(const char *obj, const gchar * iface, const char *name)
{
GError *error = NULL;
GDBusProxy *proxy;
GVariant *asv = NULL;
GVariant *value = NULL;
GVariant *_ret = NULL;
char *output = NULL;
crm_trace("Calling GetAll on %s", obj);
proxy = get_proxy(obj, BUS_PROPERTY_IFACE);
if (!proxy) {
return NULL;
}
_ret = g_dbus_proxy_call_sync(proxy, "GetAll", g_variant_new("(s)", iface),
G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
if (error) {
crm_err("Cannot get properties for %s: %s", g_dbus_proxy_get_object_path(proxy),
error->message);
g_error_free(error);
g_object_unref(proxy);
return NULL;
}
crm_debug("Call to GetAll passed: type '%s' %d\n", g_variant_get_type_string(_ret),
g_variant_n_children(_ret));
asv = g_variant_get_child_value(_ret, 0);
crm_trace("asv type '%s' %d\n", g_variant_get_type_string(asv), g_variant_n_children(asv));
value = g_variant_lookup_value(asv, name, NULL);
if (value && g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) {
crm_info("Got value '%s' for %s[%s]", g_variant_get_string(value, NULL), obj, name);
output = g_variant_dup_string(value, NULL);
} else {
crm_info("No value for %s[%s]", obj, name);
}
g_object_unref(proxy);
g_variant_unref(_ret);
return output;
}
gchar* get_version() {
g_type_init();
GDBusProxy* UD2_Manager_Proxy = NULL;
GError* error=NULL;
UD2_Manager_Proxy = g_dbus_proxy_new_for_bus_sync(G_BUS_TYPE_SYSTEM,
G_DBUS_PROXY_FLAGS_NONE,
NULL,
UD2_DBUS_NAME,
UD2_MANAGER_PATH,
DBUS_PROP_IFACE,
NULL,
&error);
if (!UD2_Manager_Proxy) {
g_printerr("%s\n", error->message);
g_error_free(error);
}
GVariant* UD2_Version = g_dbus_proxy_call_sync( UD2_Manager_Proxy,
(gchar*) "Get",
g_variant_new( "(ss)",
"org.freedesktop.UDisks2.Manager",
"Version"
),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (!UD2_Version) {
g_printerr("%s\n", error->message);
g_error_free(error);
}
GVariant* version_string;
g_variant_get(UD2_Version, "(v)", &version_string);
/* version is allocated independently from the GVariants */
gchar* version=g_variant_dup_string(version_string, NULL);
g_variant_unref(version_string);
g_variant_unref(UD2_Version);
g_object_unref(UD2_Manager_Proxy);
return version;
}
static void
try_update_version (NMShellWatcher *watcher)
{
NMShellWatcherPrivate *priv = watcher->priv;
GVariant *v;
char *version, *p;
v = g_dbus_proxy_get_cached_property (priv->shell_proxy, "ShellVersion");
if (!v) {
/* The shell has claimed the name, but not yet registered its interfaces...
* (https://bugzilla.gnome.org/show_bug.cgi?id=673182). There's no way
* to make GDBusProxy re-read the properties at this point, so we
* have to destroy this proxy and try again.
*/
if (priv->signal_id) {
g_signal_handler_disconnect (priv->shell_proxy, priv->signal_id);
priv->signal_id = 0;
}
g_object_unref (priv->shell_proxy);
priv->shell_proxy = NULL;
priv->retry_timeout = g_timeout_add_seconds (2, retry_create_shell_proxy, watcher);
return;
}
g_warn_if_fail (g_variant_is_of_type (v, G_VARIANT_TYPE_STRING));
version = g_variant_dup_string (v, NULL);
if (version) {
guint major, minor;
major = strtoul (version, &p, 10);
if (*p == '.')
minor = strtoul (p + 1, NULL, 10);
else
minor = 0;
g_warn_if_fail (major < 256);
g_warn_if_fail (minor < 256);
priv->shell_version = (major << 8) | minor;
g_object_notify (G_OBJECT (watcher), "shell-version");
}
g_variant_unref (v);
}
char *
gnome_settings_get_chassis_type (void)
{
char *ret = NULL;
GError *error = NULL;
GVariant *inner;
GVariant *variant = NULL;
GDBusConnection *connection;
connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM,
NULL,
&error);
if (connection == NULL) {
g_warning ("system bus not available: %s", error->message);
g_error_free (error);
goto out;
}
variant = g_dbus_connection_call_sync (connection,
"org.freedesktop.hostname1",
"/org/freedesktop/hostname1",
"org.freedesktop.DBus.Properties",
"Get",
g_variant_new ("(ss)",
"org.freedesktop.hostname1",
"Chassis"),
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (variant == NULL) {
g_debug ("Failed to get property '%s': %s", "Chassis", error->message);
g_error_free (error);
goto out;
}
g_variant_get (variant, "(v)", &inner);
ret = g_variant_dup_string (inner, NULL);
g_variant_unref (inner);
out:
g_clear_object (&connection);
g_clear_pointer (&variant, g_variant_unref);
return ret;
}
static gchar *
get_profile_for_window (GdkWindow *window)
{
GError *error = NULL;
guint xid;
gchar *icc_profile = NULL;
GVariant *args = NULL;
GVariant *response = NULL;
GVariant *response_child = NULL;
GVariantIter *iter = NULL;
/* get color profile */
xid = GDK_WINDOW_XID (window);
args = g_variant_new ("(u)", xid),
response = g_dbus_connection_call_sync (connection,
"org.gnome.ColorManager",
"/org/gnome/ColorManager",
"org.gnome.ColorManager",
"GetProfileForWindow",
args,
G_VARIANT_TYPE ("(s)"),
G_DBUS_CALL_FLAGS_NONE,
-1, NULL, &error);
if (response == NULL)
{
/* not a warning, as GCM might not be installed / running */
g_debug ("The GetProfileForWindow request failed: %s",
error->message);
g_error_free (error);
goto out;
}
/* get icc profile filename */
response_child = g_variant_get_child_value (response, 0);
icc_profile = g_variant_dup_string (response_child, NULL);
out:
if (iter != NULL)
g_variant_iter_free (iter);
if (args != NULL)
g_variant_unref (args);
if (response != NULL)
g_variant_unref (response);
return icc_profile;
}
static gboolean
demarshal_dhcp_options (NMObject *object, GParamSpec *pspec, GVariant *value, gpointer field)
{
NMDhcpConfigPrivate *priv = NM_DHCP_CONFIG_GET_PRIVATE (object);
GVariantIter iter;
const char *key;
GVariant *opt;
g_hash_table_remove_all (priv->options);
g_variant_iter_init (&iter, value);
while (g_variant_iter_next (&iter, "{&sv}", &key, &opt)) {
g_hash_table_insert (priv->options, g_strdup (key), g_variant_dup_string (opt, NULL));
g_variant_unref (opt);
}
_nm_object_queue_notify (object, NM_DHCP_CONFIG_OPTIONS);
return TRUE;
}
/*****************************************************************************
* neardal_tag_prv_read_properties: Get Neard Tag Properties
****************************************************************************/
static errorCode_t neardal_tag_prv_read_properties(TagProp *tagProp)
{
errorCode_t err = NEARDAL_SUCCESS;
GVariant *tmp = NULL;
GVariant *tmpOut = NULL;
gsize len;
NEARDAL_TRACEIN();
NEARDAL_ASSERT_RET(tagProp != NULL, NEARDAL_ERROR_INVALID_PARAMETER);
NEARDAL_ASSERT_RET(tagProp->proxy != NULL
, NEARDAL_ERROR_GENERAL_ERROR);
tmp = g_datalist_get_data(&(neardalMgr.dbus_data), tagProp->name);
if (tmp == NULL) {
err = NEARDAL_ERROR_NO_TAG;
NEARDAL_TRACE_ERR("Unable to read tag's properties\n");
goto exit;
}
NEARDAL_TRACEF("Reading:\n%s\n", g_variant_print(tmp, TRUE));
tmpOut = g_variant_lookup_value(tmp, "TagType", G_VARIANT_TYPE_ARRAY);
if (tmpOut != NULL) {
tagProp->tagType = g_variant_dup_strv(tmpOut, &len);
tagProp->tagTypeLen = len;
if (len == 0) {
g_strfreev(tagProp->tagType);
tagProp->tagType = NULL;
}
}
tmpOut = g_variant_lookup_value(tmp, "Type", G_VARIANT_TYPE_STRING);
if (tmpOut != NULL)
tagProp->type = g_variant_dup_string(tmpOut, NULL);
tmpOut = g_variant_lookup_value(tmp, "ReadOnly",
G_VARIANT_TYPE_BOOLEAN);
if (tmpOut != NULL)
tagProp->readOnly = g_variant_get_boolean(tmpOut);
exit:
return err;
}
connman_service_t *connman_service_new(GVariant *variant)
{
if(NULL == variant)
return NULL;
connman_service_t *service = g_new0(connman_service_t, 1);
if(service == NULL)
{
WCA_LOG_FATAL("Out of memory !!!");
return NULL;
}
GVariant *service_v = g_variant_get_child_value(variant, 0);
service->path = g_variant_dup_string(service_v, NULL);
GError *error = NULL;
service->remote = connman_interface_service_proxy_new_for_bus_sync(G_BUS_TYPE_SYSTEM,
G_DBUS_PROXY_FLAGS_NONE,
"net.connman",
service->path,
NULL,
&error);
if (error)
{
WCA_LOG_CRITICAL("%s", error->message);
g_error_free(error);
g_free(service);
return NULL;
}
g_dbus_proxy_set_default_timeout(service->remote, DBUS_CALL_TIMEOUT);
service->sighandler_id = g_signal_connect_data(G_OBJECT(service->remote), "property-changed",
G_CALLBACK(property_changed_cb), service, NULL, 0);
GVariant *properties = g_variant_get_child_value(variant, 1);
connman_service_update_properties(service, properties);
return service;
}
static void _dbus_geany_dbus_application_open_document (GeanyDBusApplication* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
GError* error;
char* filename = NULL;
GVariant* _tmp0_;
gboolean result;
GVariantIter _arguments_iter;
GVariant* _reply;
GVariantBuilder _reply_builder;
error = NULL;
g_variant_iter_init (&_arguments_iter, parameters);
_tmp0_ = g_variant_iter_next_value (&_arguments_iter);
filename = g_variant_dup_string (_tmp0_, NULL);
g_variant_unref (_tmp0_);
result = geany_dbus_application_open_document (self, filename);
g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
_g_free0 (filename);
g_variant_builder_add_value (&_reply_builder, g_variant_new_boolean (result));
_reply = g_variant_builder_end (&_reply_builder);
g_dbus_method_invocation_return_value (invocation, _reply);
}
