自学教程：C++ G_DBUS_PROXY函数代码示例

/** * fcitx_input_method_set_imlist: * @im: A #FcitxInputMethod * @array: (element-type FcitxIMItem) (transfer none): A #FcitxIMItem List * * Set Fcitx all im list **/FCITX_EXPORT_APIvoidfcitx_input_method_set_imlist(FcitxInputMethod *im, GPtrArray* array){    GVariantBuilder builder;    g_variant_builder_init(&builder, G_VARIANT_TYPE("a(sssb)"));    g_ptr_array_foreach(array, _fcitx_im_item_foreach_cb, &builder);    GVariant* value = g_variant_builder_end(&builder);    GError* error = NULL;    GVariant* result = g_dbus_connection_call_sync(g_dbus_proxy_get_connection(G_DBUS_PROXY(im)),                       g_dbus_proxy_get_name(G_DBUS_PROXY(im)),                       FCITX_IM_DBUS_PATH,                       "org.freedesktop.DBus.Properties",                       "Set",                       g_variant_new("(ssv)", FCITX_IM_DBUS_INTERFACE, "IMList", value),                       G_VARIANT_TYPE_UNIT,                       G_DBUS_CALL_FLAGS_NONE,                       -1,           /* timeout */                       NULL,                       &error);    if (error) {        g_warning("%s", error->message);        g_error_free(error);    }    g_variant_unref(result);}

static gbooleanhandle_prepare_print (XdpPrint *object,                      GDBusMethodInvocation *invocation,                      const gchar *arg_parent_window,                      const gchar *arg_title,                      GVariant *arg_settings,                      GVariant *arg_page_setup,                      GVariant *arg_options){  Request *request = request_from_invocation (invocation);  const char *app_id = xdp_app_info_get_id (request->app_info);  g_autoptr(GError) error = NULL;  g_autoptr(XdpImplRequest) impl_request = NULL;  GVariantBuilder opt_builder;  if (xdp_impl_lockdown_get_disable_printing (lockdown))    {      g_debug ("Printing disabled");      g_dbus_method_invocation_return_error (invocation,                                             XDG_DESKTOP_PORTAL_ERROR,                                             XDG_DESKTOP_PORTAL_ERROR_NOT_ALLOWED,                                             "Printing disabled");      return TRUE;    }  REQUEST_AUTOLOCK (request);  impl_request = xdp_impl_request_proxy_new_sync (g_dbus_proxy_get_connection (G_DBUS_PROXY (impl)),                                                  G_DBUS_PROXY_FLAGS_NONE,                                                  g_dbus_proxy_get_name (G_DBUS_PROXY (impl)),                                                  request->id,                                                  NULL, &error);  if (!impl_request)    {      g_dbus_method_invocation_return_gerror (invocation, error);      return TRUE;    }  request_set_impl_request (request, impl_request);  request_export (request, g_dbus_method_invocation_get_connection (invocation));  g_variant_builder_init (&opt_builder, G_VARIANT_TYPE_VARDICT);  xdp_filter_options (arg_options, &opt_builder,                      prepare_print_options, G_N_ELEMENTS (prepare_print_options));  xdp_impl_print_call_prepare_print (impl,                                     request->id,                                     app_id,                                     arg_parent_window,                                     arg_title,                                     arg_settings,                                     arg_page_setup,                                     g_variant_builder_end (&opt_builder),                                     NULL,                                     prepare_print_done,                                     g_object_ref (request));  xdp_print_complete_prepare_print (object, invocation, request->id);  return TRUE;}

static void_parent_init_async_cb (GObject      *obj,                       GAsyncResult *res,                       gpointer      user_data){    InitData *data;    data = (InitData*)user_data;    /* start our own initialization */    g_dbus_proxy_call (G_DBUS_PROXY (obj),                       "GetProperties",                       NULL,                       G_DBUS_CALL_FLAGS_NONE,                       -1,                       data->cancellable,                       _get_properties_cb,                       data);    g_dbus_proxy_call (G_DBUS_PROXY (obj),                       "GetServices",                       NULL,                       G_DBUS_CALL_FLAGS_NONE,                       -1,                       data->cancellable,                       _get_services_cb,                       data);    g_signal_connect (obj, "notify::g-name-owner",                      G_CALLBACK (_name_owner_notify_cb), NULL);}

static gbooleanmtn_connman_initable_init_sync (GInitable     *initable,                                GCancellable  *cancellable,                                GError       **error){    GInitableIface *iface_class, *parent_iface_class;    GVariant *var, *value;    GVariantIter *iter;    char *key;    MtnConnman *connman;    connman = MTN_CONNMAN (initable);    /* Chain up the old method */    iface_class = G_INITABLE_GET_IFACE (initable);    parent_iface_class = g_type_interface_peek_parent (iface_class);    if (!parent_iface_class->init (initable, cancellable, error)) {        return FALSE;    }    g_signal_connect (connman, "notify::g-name-owner",                      G_CALLBACK (_name_owner_notify_cb), NULL);    var = g_dbus_proxy_call_sync (G_DBUS_PROXY (connman),                                  "GetProperties",                                  NULL,                                  G_DBUS_CALL_FLAGS_NONE,                                  -1,                                  NULL,                                  error);    if (!var) {        return FALSE;    }    g_variant_get (var, "(a{sv})", &iter);    while (g_variant_iter_next (iter, "{sv}", &key, &value)) {        g_hash_table_insert (connman->priv->properties,                             key, value);    }    g_variant_iter_free (iter);    g_variant_unref (var);    var = g_dbus_proxy_call_sync (G_DBUS_PROXY (connman),                                  "GetServices",                                  NULL,                                  G_DBUS_CALL_FLAGS_NONE,                                  -1,                                  NULL,                                  error);    if (!var) {        return FALSE;    }    connman->priv->services = var;    return TRUE;}

static voidadd_interface (JsonBuilder *builder,               GDBusInterface *interface,               GVariant *changed_properties){  gchar *s;  json_builder_set_member_name (builder, g_dbus_proxy_get_interface_name (G_DBUS_PROXY (interface)));  json_builder_begin_object (builder);  if (changed_properties == NULL)    {      gchar **properties;      guint n;      properties = g_dbus_proxy_get_cached_property_names (G_DBUS_PROXY (interface));      for (n = 0; properties != NULL && properties[n] != NULL; n++)        {          const gchar *property_name = properties[n];          GVariant *value;          value = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (interface), property_name);          if (value != NULL)            {              s = g_strconcat ("dbus_prop_", property_name, NULL);              json_builder_set_member_name (builder, s);              g_free (s);              _json_builder_add_gvariant (builder, value);              g_variant_unref (value);            }        }      g_strfreev (properties);      if (properties == NULL)        {          json_builder_set_member_name (builder, "HackEmpty");          json_builder_add_string_value (builder, "HackEmpty");        }    }  else    {      GVariantIter iter;      const gchar *property_name;      GVariant *value;      g_variant_iter_init (&iter, changed_properties);      while (g_variant_iter_next (&iter, "{&sv}", &property_name, &value))        {          s = g_strconcat ("dbus_prop_", property_name, NULL);          json_builder_set_member_name (builder, property_name);          g_free (s);          _json_builder_add_gvariant (builder, value);          g_variant_unref (value);        }    }  json_builder_end_object (builder);}

/** * fcitx_input_method_get_imlist_nofree: (rename-to fcitx_input_method_get_imlist) * @im: A #FcitxInputMethod * * Get Fcitx all im list * * Returns: (transfer full) (element-type FcitxIMItem): A #FcitxIMItem List * * Rename to: fcitx_input_method_get_imlist **/FCITX_EXPORT_APIGPtrArray*fcitx_input_method_get_imlist_nofree(FcitxInputMethod* im){    GPtrArray *array = NULL;    GVariant* value;    GVariantIter *iter;    gchar *name, *unique_name, *langcode;    gboolean enable;    value = g_dbus_proxy_get_cached_property(G_DBUS_PROXY(im), "IMList");    if (value == NULL) {        GError* error = NULL;        GVariant* result = g_dbus_connection_call_sync(g_dbus_proxy_get_connection(G_DBUS_PROXY(im)),                           g_dbus_proxy_get_name(G_DBUS_PROXY(im)),                           FCITX_IM_DBUS_PATH,                           "org.freedesktop.DBus.Properties",                           "Get",                           g_variant_new("(ss)", FCITX_IM_DBUS_INTERFACE, "IMList"),                           G_VARIANT_TYPE("(v)"),                           G_DBUS_CALL_FLAGS_NONE,                           -1,           /* timeout */                           NULL,                           &error);        if (error) {            g_warning("%s", error->message);            g_error_free(error);        } else if (result) {            g_variant_get(result, "(v)", &value);            g_variant_unref(result);        }    }    if (value) {        array = g_ptr_array_new();        g_variant_get(value, "a(sssb)", &iter);        while (g_variant_iter_next(iter, "(sssb)", &name, &unique_name, &langcode, &enable, NULL)) {            FcitxIMItem *item = g_slice_new(FcitxIMItem);            item->name = name;            item->unique_name = unique_name;            item->langcode = langcode;            item->enable = enable;            g_ptr_array_add(array, item);        }        g_variant_iter_free(iter);        g_variant_unref(value);    }    return array;}

static gbooleanhandle_save_file (XdpFileChooser *object,                  GDBusMethodInvocation *invocation,                  const gchar *arg_parent_window,                  const gchar *arg_title,                  GVariant *arg_options){  Request *request = request_from_invocation (invocation);  const char *app_id = request->app_id;  g_autoptr(GError) error = NULL;  XdpImplRequest *impl_request;  GVariantBuilder options;  REQUEST_AUTOLOCK (request);  g_variant_builder_init (&options, G_VARIANT_TYPE_VARDICT);  xdp_filter_options (arg_options, &options,                      save_file_options, G_N_ELEMENTS (save_file_options));  impl_request = xdp_impl_request_proxy_new_sync (g_dbus_proxy_get_connection (G_DBUS_PROXY (impl)),                                                  G_DBUS_PROXY_FLAGS_NONE,                                                  g_dbus_proxy_get_name (G_DBUS_PROXY (impl)),                                                  request->id,                                                  NULL, &error);  if (!impl_request)    {      g_dbus_method_invocation_return_gerror (invocation, error);      return TRUE;    }  g_object_set_data (G_OBJECT (request), "for-save", GINT_TO_POINTER (TRUE));  request_set_impl_request (request, impl_request);  request_export (request, g_dbus_method_invocation_get_connection (invocation));  xdp_impl_file_chooser_call_save_file (impl,                                        request->id,                                        app_id,                                        arg_parent_window,                                        arg_title,                                        g_variant_builder_end (&options),                                        NULL,                                        save_file_done,                                        g_object_ref (request));  xdp_file_chooser_complete_open_file (object, invocation, request->id);  return TRUE;}

static gbooleanhandle_empty_device (CockpitStorageVolumeGroup *object,                     GDBusMethodInvocation *invocation,                     const gchar *arg_objpath){  StorageVolumeGroup *group = STORAGE_VOLUME_GROUP(object);  GError *error = NULL;  const gchar *block_path = "/";  if (!auth_check_sender_role (invocation, COCKPIT_ROLE_STORAGE_ADMIN))    return TRUE;  StorageProvider *provider = storage_object_get_provider (group->object);  Daemon *daemon = storage_provider_get_daemon (provider);  GDBusObjectManagerServer *object_manager_server = daemon_get_object_manager (daemon);  GDBusObjectManager *object_manager = G_DBUS_OBJECT_MANAGER (object_manager_server);  StorageObject *block_object =    STORAGE_OBJECT (g_dbus_object_manager_get_object (object_manager, arg_objpath));  UDisksBlock *udisks_block = storage_object_get_udisks_block (block_object);  if (udisks_block)    block_path = g_dbus_proxy_get_object_path (G_DBUS_PROXY (udisks_block));  g_dbus_proxy_set_default_timeout (G_DBUS_PROXY (group->lvm_volume_group),                                    G_MAXINT);  if (!lvm_volume_group_call_empty_device_sync (group->lvm_volume_group,                                                block_path,                                                null_asv (),                                                NULL,                                                &error))    {      g_dbus_error_strip_remote_error (error);      g_dbus_method_invocation_return_error (invocation,                                             COCKPIT_ERROR,                                             COCKPIT_ERROR_FAILED,                                             "%s", error->message);      g_error_free (error);    }  else    cockpit_storage_volume_group_complete_empty_device (object, invocation);  g_dbus_proxy_set_default_timeout (G_DBUS_PROXY (group->lvm_volume_group),                                    -1);  return TRUE;}

const gchar *storage_block_get_object_path (StorageBlock *self){  g_return_val_if_fail (STORAGE_IS_BLOCK (self), NULL);  g_return_val_if_fail (self->real_block != NULL, NULL);  return g_dbus_proxy_get_object_path (G_DBUS_PROXY (self->real_block));}

static voidon_udisks_object_added (GDBusObjectManager *manager,                        GDBusObject *object,                        gpointer user_data){  FormatData *data = user_data;  if (data->invocation == NULL)    return;  UDisksObject *udisks_object = UDISKS_OBJECT (object);  UDisksJob *udisks_job = udisks_object_peek_job (udisks_object);  if (udisks_job)    {      const gchar *us = g_dbus_proxy_get_object_path (G_DBUS_PROXY (data->block));      const gchar *const *them = udisks_job_get_objects (udisks_job);      for (int i = 0; them[i]; i++)        {          if (strcmp (them[i], us) == 0)            {              g_dbus_method_invocation_return_value (data->invocation, g_variant_new ("()"));              g_clear_object (&data->invocation);              break;            }        }    }}

static voidinhibit_done (GObject      *source,              GAsyncResult *result,              gpointer      user_data){    GDBusProxy *sd_proxy = G_DBUS_PROXY (source);    NMSleepMonitor *self = user_data;    GError *error = NULL;    GVariant *res;    GUnixFDList *fd_list;    res = g_dbus_proxy_call_with_unix_fd_list_finish (sd_proxy, &fd_list, result, &error);    if (!res) {        g_dbus_error_strip_remote_error (error);        nm_log_warn (LOGD_SUSPEND, "Inhibit failed: %s", error->message);        g_error_free (error);    } else {        if (!fd_list || g_unix_fd_list_get_length (fd_list) != 1)            nm_log_warn (LOGD_SUSPEND, "Didn't get a single fd back");        self->inhibit_fd = g_unix_fd_list_get (fd_list, 0, NULL);        nm_log_dbg (LOGD_SUSPEND, "Inhibitor fd is %d", self->inhibit_fd);        g_object_unref (fd_list);        g_variant_unref (res);    }}

static voidon_list_units_done (GObject *object,                    GAsyncResult *res,                    gpointer user_data){  ListServicesData *data = user_data;  GError *error = NULL;  data->units = g_dbus_proxy_call_finish (G_DBUS_PROXY (object), res, &error);  if (error)    {      end_invocation_take_gerror (data->invocation, error);      g_free (data);      return;    }  g_dbus_proxy_call (data->services->systemd,                     "ListUnitFiles",                     NULL,                     G_DBUS_CALL_FLAGS_NONE,                     G_MAXINT,                     NULL,                     on_list_files_done,                     data);}

static void_set_property_cb (GObject *object,                  GAsyncResult *res,                  gpointer user_data){    char *key;    GVariant *var;    GError *error;    key = (char *)user_data;    error = NULL;    var = g_dbus_proxy_call_finish (G_DBUS_PROXY (object),                                    res,                                    &error);    if (var) {        g_variant_unref (var);    } else if (error) {        g_warning ("Connman Manager.SetProperty() for '%s' failed: %s",                   key, error->message);        /* TODO: call a error handler method */        g_error_free (error);    }    g_free (key);}

/** * fcitx_kbd_set_default_layout: * @kbd: A #FcitxKbd * @layout: layout * @variant: variant * * Set a layout binding with the state when there is no input method **/FCITX_EXPORT_APIvoid fcitx_kbd_set_default_layout(FcitxKbd *kbd, const gchar *layout,                                  const gchar *variant) {    g_dbus_proxy_call(G_DBUS_PROXY(kbd), "SetDefaultLayout",                      g_variant_new("(ss)", layout, variant),                      G_DBUS_CALL_FLAGS_NO_AUTO_START, 0, NULL, NULL, NULL);}

static voidon_get_user_id_ready (GObject      *source_object,                      GAsyncResult *res,                      gpointer      user_data){        GTask *task = G_TASK (user_data);        gpointer *info = g_task_get_source_object (task);        GClueClientInfoPrivate *priv = GCLUE_CLIENT_INFO (info)->priv;        GError *error = NULL;        GVariant *results = NULL;        results = g_dbus_proxy_call_finish (G_DBUS_PROXY (source_object),                                            res,                                            &error);        if (results == NULL) {                g_task_return_error (task, error);                g_object_unref (task);                return;        }        g_assert (g_variant_n_children (results) > 0);        g_variant_get_child (results, 0, "u", &priv->user_id);        g_variant_unref (results);        g_dbus_proxy_call (priv->dbus_proxy,                           "GetConnectionUnixProcessID",                           g_variant_new ("(s)", priv->bus_name),                           G_DBUS_CALL_FLAGS_NONE,                           -1,                           g_task_get_cancellable (task),                           on_get_pid_ready,                           task);}

SecretPrompt *_secret_prompt_instance (SecretService *service,                         const gchar *prompt_path){	GDBusProxy *proxy;	SecretPrompt *prompt;	GError *error = NULL;	g_return_val_if_fail (SECRET_IS_SERVICE (service), NULL);	g_return_val_if_fail (prompt_path != NULL, NULL);	proxy = G_DBUS_PROXY (service);	prompt = g_initable_new (SECRET_TYPE_PROMPT, NULL, &error,	                         "g-flags", G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,	                         "g-interface-info", _secret_gen_prompt_interface_info (),	                         "g-name", g_dbus_proxy_get_name (proxy),	                         "g-connection", g_dbus_proxy_get_connection (proxy),	                         "g-object-path", prompt_path,	                         "g-interface-name", SECRET_PROMPT_INTERFACE,	                         NULL);	if (error != NULL) {		g_warning ("couldn't create SecretPrompt object: %s", error->message);		g_clear_error (&error);		return NULL;	}	return prompt;}

static voidon_prompt_dismissed (GObject *source,                     GAsyncResult *result,                     gpointer user_data){	GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);	PerformClosure *closure = g_simple_async_result_get_op_res_gpointer (res);	SecretPrompt *self = SECRET_PROMPT (source);	GError *error = NULL;	GVariant *retval;	retval = g_dbus_proxy_call_finish (G_DBUS_PROXY (self), result, &error);	if (retval)		g_variant_unref (retval);	if (closure->vanished)		g_clear_error (&error);	if (g_error_matches (error, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD))		g_clear_error (&error);	if (error != NULL) {		g_simple_async_result_take_error (res, error);		perform_prompt_complete (res, TRUE);	}	g_object_unref (res);}

static voidon_prompt_prompted (GObject *source,                    GAsyncResult *result,                    gpointer user_data){	GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);	PerformClosure *closure = g_simple_async_result_get_op_res_gpointer (res);	SecretPrompt *self = SECRET_PROMPT (source);	GError *error = NULL;	GVariant *retval;	retval = g_dbus_proxy_call_finish (G_DBUS_PROXY (self), result, &error);	if (retval)		g_variant_unref (retval);	if (closure->vanished)		g_clear_error (&error);	if (error != NULL) {		g_simple_async_result_take_error (res, error);		perform_prompt_complete (res, TRUE);	} else {		closure->prompting = TRUE;		g_atomic_int_set (&self->pv->prompted, 1);		/* And now we wait for the signal */	}	g_object_unref (res);}

static void get_capabilities_callback(GObject* source, GAsyncResult* res, gpointer user_data UNUSED){    char** caps;    GVariant* result;    result = g_dbus_proxy_call_finish(G_DBUS_PROXY(source), res, NULL);    if (result == NULL || !g_variant_is_of_type(result, G_VARIANT_TYPE("(as)")))    {        if (result != NULL)        {            g_variant_unref(result);        }        return;    }    g_variant_get(result, "(^a&s)", &caps);    for (int i = 0; caps[i] != NULL; i++)    {        if (g_strcmp0(caps[i], "actions") == 0)        {            server_supports_actions = TRUE;            break;        }    }    g_free(caps);    g_variant_unref(result);}

/** * fcitx_input_method_get_current_state: * @im: A #FcitxInputMethod * * Get current state * * Returns: current state, -1 for error **/FCITX_EXPORT_APIgint fcitx_input_method_get_current_state(FcitxInputMethod* im){    GError* error = NULL;    GVariant* variant = g_dbus_proxy_call_sync(G_DBUS_PROXY(im),                                               "GetCurrentState",                                               NULL,                                               G_DBUS_CALL_FLAGS_NO_AUTO_START,                                               -1,                                               NULL,                                               &error                                              );    gint result = -1;    if (error) {        g_warning("%s", error->message);        g_error_free(error);    } else if (variant) {        g_variant_get(variant, "(i)", &result);        g_variant_unref(variant);    }    return result;}

/** * fcitx_input_method_get_im_addon: * @im: A #FcitxInputMethod * @imname: (transfer none): imname * * Get addon name by im * * Returns: (transfer full): get addon name **/FCITX_EXPORT_APIgchar* fcitx_input_method_get_im_addon(FcitxInputMethod* im, gchar* imname){    GError* error = NULL;    GVariant* variant = g_dbus_proxy_call_sync(G_DBUS_PROXY(im),                                               "GetIMAddon",                                               g_variant_new("(s)", imname),                                               G_DBUS_CALL_FLAGS_NO_AUTO_START,                                               -1,                                               NULL,                                               &error                                              );    gchar* result = NULL;    if (error) {        g_warning("%s", error->message);        g_error_free(error);    } else if (variant) {        g_variant_get(variant, "(s)", &result);        g_variant_unref(variant);    }    return result;}

static voidstorage_manager_constructed (GObject *_object){  StorageManager *storage_manager = STORAGE_MANAGER (_object);  GError *error = NULL;  storage_manager->udisks = udisks_client_new_sync (NULL, &error);  if (storage_manager->udisks == NULL)    {      g_warning ("Error connecting to udisks: %s (%s, %d)",                 error->message, g_quark_to_string (error->domain), error->code);      g_clear_error (&error);    }  storage_manager->lvm_manager =    lvm_manager_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,                                        0,                                        "com.redhat.storaged",                                        "/org/freedesktop/UDisks2/Manager",                                        NULL,                                        &error);  if (storage_manager->lvm_manager == NULL)    {      g_warning ("Error connecting to storaged: %s (%s, %d)",                 error->message, g_quark_to_string (error->domain), error->code);      g_clear_error (&error);    }  g_dbus_proxy_set_default_timeout (G_DBUS_PROXY (storage_manager->lvm_manager), G_MAXINT);  if (G_OBJECT_CLASS (storage_manager_parent_class)->constructed != NULL)    G_OBJECT_CLASS (storage_manager_parent_class)->constructed (_object);}

static voidgoa_dlna_server_manager_server_new_cb (GObject      *source_object,                                       GAsyncResult *res,                                       gpointer      user_data){  GoaDlnaServerManager *self = GOA_DLNA_SERVER_MANAGER (user_data);  DleynaServerMediaDevice *server;  GError *error = NULL;  const gchar *object_path;  server = dleyna_server_media_device_proxy_new_for_bus_finish (res, &error);  if (error != NULL)    {      g_warning ("Unable to load server object: %s", error->message);      g_error_free (error);      goto out;    }  object_path = g_dbus_proxy_get_object_path (G_DBUS_PROXY (server));  g_debug ("%s '%s' %s %s",           G_STRFUNC,           dleyna_server_media_device_get_friendly_name (server),           dleyna_server_media_device_get_udn (server),           object_path);  g_hash_table_insert (self->servers, (gpointer) object_path, server);  g_signal_emit (self, signals[SERVER_FOUND], 0, server); out:  g_object_unref (self);}

/** * gca_service_call_parse_sync: * @proxy: A #GcaServiceProxy. * @arg_path: Argument to pass with the method invocation. * @arg_data_path: Argument to pass with the method invocation. * @arg_cursor: Argument to pass with the method invocation. * @arg_options: Argument to pass with the method invocation. * @out_unnamed_arg4: (out): Return location for return parameter or %NULL to ignore. * @cancellable: (allow-none): A #GCancellable or %NULL. * @error: Return location for error or %NULL. * * Synchronously invokes the <link linkend="gdbus-method-org-gnome-CodeAssist-v1-Service.Parse">Parse()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received. * * See gca_service_call_parse() for the asynchronous version of this method. * * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. */gbooleangca_service_call_parse_sync (    GcaService *proxy,    const gchar *arg_path,    const gchar *arg_data_path,    GVariant *arg_cursor,    GVariant *arg_options,    gchar **out_unnamed_arg4,    GCancellable *cancellable,    GError **error){  GVariant *_ret;  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),    "Parse",    g_variant_new ("([email
C++ G_DEF_CLASS函数代码示例
C++ G_DBUS_OBJECT_SKELETON函数代码示例