static void
on_bus_acquired (GDBusConnection *connection,
const gchar *name,
gpointer user_data)
{
GError *error = NULL;
g_debug ("Bus acquired, creating skeleton");
helper = flatpak_system_helper_skeleton_new ();
g_object_set_data_full (G_OBJECT(helper), "track-alive", GINT_TO_POINTER(42), skeleton_died_cb);
g_dbus_interface_skeleton_set_flags (G_DBUS_INTERFACE_SKELETON (helper),
G_DBUS_INTERFACE_SKELETON_FLAGS_HANDLE_METHOD_INVOCATIONS_IN_THREAD);
g_signal_connect (helper, "handle-deploy", G_CALLBACK (handle_deploy), NULL);
g_signal_connect (helper, "handle-deploy-appstream", G_CALLBACK (handle_deploy_appstream), NULL);
g_signal_connect (helper, "handle-uninstall", G_CALLBACK (handle_uninstall), NULL);
g_signal_connect (helper, "handle-install-bundle", G_CALLBACK (handle_install_bundle), NULL);
g_signal_connect (helper, "handle-configure-remote", G_CALLBACK (handle_configure_remote), NULL);
g_signal_connect (helper, "g-authorize-method",
G_CALLBACK (flatpak_authorize_method_handler),
NULL);
if (!g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (helper),
connection,
"/org/freedesktop/Flatpak/SystemHelper",
&error))
{
g_warning ("error: %s\n", error->message);
g_error_free (error);
}
}
static void hev_dbus_object_test_notify_value_handler(GObject *obj,
GParamSpec *pspec, gpointer user_data)
{
HevDBusInterfaceTest *self = HEV_DBUS_INTERFACE_TEST(user_data);
HevDBusInterfaceTestPrivate *priv = HEV_DBUS_INTERFACE_TEST_GET_PRIVATE(self);
GDBusConnection *connection = NULL;
const gchar *object_path = NULL;
GVariantBuilder *builder = NULL;
GVariant *variant = NULL;
gchar *p = NULL;
g_debug("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__);
connection = g_dbus_interface_skeleton_get_connection(G_DBUS_INTERFACE_SKELETON(self));
object_path = g_dbus_interface_skeleton_get_object_path(G_DBUS_INTERFACE_SKELETON(self));
builder = g_variant_builder_new(G_VARIANT_TYPE_VARDICT);
g_object_get(obj, "value", &p, NULL);
g_variant_builder_add(builder, "{sv}", "Value", g_variant_new_string(p));
variant = g_variant_builder_end(builder);
g_variant_builder_unref(builder);
variant = g_variant_new("(@a{sv})", variant);
g_free(p);
g_dbus_connection_emit_signal(connection, NULL, object_path,
"org.freedesktop.DBus.Properties", "PropertiesChanged",
variant, NULL);
g_variant_unref(variant);
}
static gboolean
update_iface (StoragedObject *object,
const gchar *uevent_action,
StoragedObjectHasInterfaceFunc has_func,
StoragedObjectConnectInterfaceFunc connect_func,
StoragedObjectUpdateInterfaceFunc update_func,
GType skeleton_type,
gpointer _interface_pointer)
{
gboolean ret = FALSE;
gboolean has;
gboolean add;
GDBusInterface **interface_pointer = _interface_pointer;
g_return_val_if_fail (object != NULL, FALSE);
g_return_val_if_fail (has_func != NULL, FALSE);
g_return_val_if_fail (update_func != NULL, FALSE);
g_return_val_if_fail (g_type_is_a (skeleton_type, G_TYPE_OBJECT), FALSE);
g_return_val_if_fail (g_type_is_a (skeleton_type, G_TYPE_DBUS_INTERFACE), FALSE);
g_return_val_if_fail (interface_pointer != NULL, FALSE);
g_return_val_if_fail (*interface_pointer == NULL || G_IS_DBUS_INTERFACE (*interface_pointer), FALSE);
add = FALSE;
has = has_func (object);
if (*interface_pointer == NULL)
{
if (has)
{
*interface_pointer = g_object_new (skeleton_type, NULL);
if (connect_func != NULL)
connect_func (object);
add = TRUE;
}
}
else
{
if (!has)
{
g_dbus_object_skeleton_remove_interface (G_DBUS_OBJECT_SKELETON (object),
G_DBUS_INTERFACE_SKELETON (*interface_pointer));
g_object_unref (*interface_pointer);
*interface_pointer = NULL;
}
}
if (*interface_pointer != NULL)
{
if (update_func (object, uevent_action, G_DBUS_INTERFACE (*interface_pointer)))
ret = TRUE;
if (add)
g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object),
G_DBUS_INTERFACE_SKELETON (*interface_pointer));
}
return ret;
}
void
gcal_shell_search_provider_dbus_unexport (GcalShellSearchProvider *search_provider,
GDBusConnection *connection,
const gchar *object_path)
{
GcalShellSearchProviderPrivate *priv = GCAL_SHELL_SEARCH_PROVIDER (search_provider)->priv;
if (g_dbus_interface_skeleton_has_connection (G_DBUS_INTERFACE_SKELETON (priv->skel), connection))
g_dbus_interface_skeleton_unexport_from_connection (G_DBUS_INTERFACE_SKELETON (priv->skel), connection);
}
static void
ensure_credentials_cb (GoaProvider *provider,
GAsyncResult *res,
gpointer user_data)
{
EnsureData *data = user_data;
gint expires_in;
GError *error;
error= NULL;
if (!goa_provider_ensure_credentials_finish (provider, &expires_in, res, &error))
{
/* Set AttentionNeeded only if the error is an authorization error */
if (is_authorization_error (error))
{
GoaAccount *account;
account = goa_object_peek_account (data->object);
if (!goa_account_get_attention_needed (account))
{
goa_account_set_attention_needed (account, TRUE);
g_dbus_interface_skeleton_flush (G_DBUS_INTERFACE_SKELETON (account));
g_message ("%s: Setting AttentionNeeded to TRUE because EnsureCredentials() failed with: %s (%s, %d)",
g_dbus_object_get_object_path (G_DBUS_OBJECT (data->object)),
error->message, g_quark_to_string (error->domain), error->code);
}
}
g_dbus_method_invocation_return_gerror (data->invocation, error);
g_error_free (error);
}
else
{
GoaAccount *account;
account = goa_object_peek_account (data->object);
/* Clear AttentionNeeded flag if set */
if (goa_account_get_attention_needed (account))
{
goa_account_set_attention_needed (account, FALSE);
g_dbus_interface_skeleton_flush (G_DBUS_INTERFACE_SKELETON (account));
g_message ("%s: Setting AttentionNeeded to FALSE because EnsureCredentials() succeded\n",
g_dbus_object_get_object_path (G_DBUS_OBJECT (data->object)));
}
goa_account_complete_ensure_credentials (goa_object_peek_account (data->object),
data->invocation,
expires_in);
}
ensure_data_unref (data);
}
static gboolean
initable_init (GInitable *initable,
GCancellable *cancellable,
GError **error)
{
MMManagerPrivate *priv = MM_MANAGER (initable)->priv;
/* Create plugin manager */
priv->plugin_manager = mm_plugin_manager_new (error);
if (!priv->plugin_manager)
return FALSE;
/* Export the manager interface */
if (!g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (initable),
priv->connection,
MM_DBUS_PATH,
error))
return FALSE;
/* Export the Object Manager interface */
g_dbus_object_manager_server_set_connection (priv->object_manager,
priv->connection);
/* All good */
return TRUE;
}
gboolean
screenshot_init (GDBusConnection *bus,
GError **error)
{
GDBusInterfaceSkeleton *helper;
helper = G_DBUS_INTERFACE_SKELETON (xdp_impl_screenshot_skeleton_new ());
g_signal_connect (helper, "handle-screenshot", G_CALLBACK (handle_screenshot), NULL);
if (!g_dbus_interface_skeleton_export (helper,
bus,
DESKTOP_PORTAL_OBJECT_PATH,
error))
return FALSE;
shell = org_gnome_shell_screenshot_proxy_new_sync (bus,
G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
"org.gnome.Shell.Screenshot",
"/org/gnome/Shell/Screenshot",
NULL,
error);
if (shell == NULL)
return FALSE;
g_debug ("providing %s", g_dbus_interface_skeleton_get_info (helper)->name);
return TRUE;
}
static void on_bus_acquired(GDBusConnection *bus,
const gchar *name,
gpointer user_data)
{
LoginKitManager *interface;
GError *error = NULL;
interface = login_kit_manager_skeleton_new();
g_signal_connect(interface,
"handle-unlock-session",
G_CALLBACK(on_handle_unlock_session),
NULL);
g_signal_connect(interface,
"handle-list-seats",
G_CALLBACK(on_handle_list_seats),
NULL);
g_signal_connect(interface,
"handle-activate-session-on-seat",
G_CALLBACK(on_handle_activate_session_on_seat),
NULL);
signals_subscribe(interface);
if (!g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(interface),
bus,
"/org/freedesktop/login1",
&error)) {
if (NULL != error)
g_error_free(error);
}
}
static gboolean
register_factory (GdmLocalDisplayFactory *factory)
{
GError *error = NULL;
error = NULL;
factory->priv->connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
if (factory->priv->connection == NULL) {
g_critical ("error getting system bus: %s", error->message);
g_error_free (error);
exit (1);
}
factory->priv->skeleton = GDM_DBUS_LOCAL_DISPLAY_FACTORY (gdm_dbus_local_display_factory_skeleton_new ());
g_signal_connect (factory->priv->skeleton,
"handle-create-transient-display",
G_CALLBACK (handle_create_transient_display),
factory);
if (!g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (factory->priv->skeleton),
factory->priv->connection,
GDM_LOCAL_DISPLAY_FACTORY_DBUS_PATH,
&error)) {
g_critical ("error exporting LocalDisplayFactory object: %s", error->message);
g_error_free (error);
exit (1);
}
return TRUE;
}
static void
on_bus_acquired (GDBusConnection *connection,
const gchar *name,
gpointer user_data)
{
TcmmdDbus *self = user_data;
GError *error = NULL;
self->priv->connection = g_object_ref (connection);
self->priv->iface = tcmmd_managed_connections_skeleton_new ();
g_signal_connect (self->priv->iface, "handle-set-policy",
G_CALLBACK (handle_set_policy_cb), self);
g_signal_connect (self->priv->iface, "handle-set-fixed-policy",
G_CALLBACK (handle_set_fixed_policy_cb), self);
g_signal_connect (self->priv->iface, "handle-unset-policy",
G_CALLBACK (handle_unset_policy_cb), self);
if (!g_dbus_interface_skeleton_export (
G_DBUS_INTERFACE_SKELETON (self->priv->iface),
self->priv->connection,
"/org/tcmmd/ManagedConnections", &error))
{
g_critical ("Failed to export iface: %s", error->message);
g_clear_error (&error);
}
}
/**
* @user_data: daemon itself
*/
static void
_on_bus_acquired (GDBusConnection *connection,
const gchar *name,
gpointer user_data)
{
RatdbProxyEngine *skeleton;
GError *error = NULL;
RatdbDaemonPrivate *priv = RATDB_DAEMON (user_data)->priv;
g_debug ("Bus acquired");
/* /org/ratdb/Interface */
skeleton = ratdb_proxy_engine_skeleton_new ();
if (error)
{
g_error (_("Couldn't create a skeleton for clients: %s"), error->message);
g_error_free (error);
}
g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (skeleton),
connection, "/org/ratdb/Interface", &error);
if (error)
{
g_error (_("Failed to export symbols: %s"), error->message);
g_error_free (error);
}
/* handle functions */
RATDB_CONNECT_DBUS_IFACE (request, ratdb_dbus_handler, priv->client_list);
RATDB_CONNECT_DBUS_IFACE (remove_client, ratdb_dbus_handler, user_data);
RATDB_CONNECT_DBUS_IFACE (new_database, ratdb_dbus_handler, user_data);
RATDB_CONNECT_DBUS_IFACE (new_table, ratdb_dbus_handler, user_data);
}
void
gkd_secret_objects_register_collection (GkdSecretObjects *self,
const gchar *collection_path)
{
GkdExportedCollection *skeleton;
GError *error = NULL;
skeleton = g_hash_table_lookup (self->collections_to_skeletons, collection_path);
if (skeleton != NULL) {
g_warning ("asked to register collection %s, but it's already registered", collection_path);
return;
}
skeleton = gkd_secret_collection_skeleton_new (self);
g_hash_table_insert (self->collections_to_skeletons, g_strdup (collection_path), skeleton);
g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (skeleton),
gkd_secret_service_get_connection (self->service),
collection_path, &error);
if (error != NULL) {
g_warning ("could not register secret collection on session bus: %s", error->message);
g_error_free (error);
}
g_signal_connect (skeleton, "handle-create-item",
G_CALLBACK (collection_method_create_item), self);
g_signal_connect (skeleton, "handle-delete",
G_CALLBACK (collection_method_delete), self);
g_signal_connect (skeleton, "handle-search-items",
G_CALLBACK (collection_method_search_items), self);
gkd_secret_objects_init_collection_items (self, collection_path);
}
static void
machines_init (Machines *machines)
{
g_dbus_interface_skeleton_set_flags (G_DBUS_INTERFACE_SKELETON (machines),
G_DBUS_INTERFACE_SKELETON_FLAGS_HANDLE_METHOD_INVOCATIONS_IN_THREAD);
g_mutex_init (&machines->lock);
}
GDBusInterfaceSkeleton *
print_create (GDBusConnection *connection,
const char *dbus_name,
gpointer lockdown_proxy)
{
g_autoptr(GError) error = NULL;
lockdown = lockdown_proxy;
impl = xdp_impl_print_proxy_new_sync (connection,
G_DBUS_PROXY_FLAGS_NONE,
dbus_name,
DESKTOP_PORTAL_OBJECT_PATH,
NULL,
&error);
if (impl == NULL)
{
g_warning ("Failed to create print proxy: %s", error->message);
return NULL;
}
g_dbus_proxy_set_default_timeout (G_DBUS_PROXY (impl), G_MAXINT);
print = g_object_new (print_get_type (), NULL);
return G_DBUS_INTERFACE_SKELETON (print);
}
static void
gkd_secret_objects_register_item (GkdSecretObjects *self,
const gchar *item_path)
{
GkdExportedItem *skeleton;
GError *error = NULL;
skeleton = g_hash_table_lookup (self->items_to_skeletons, item_path);
if (skeleton != NULL) {
g_warning ("asked to register item %s, but it's already registered", item_path);
return;
}
skeleton = gkd_secret_item_skeleton_new (self);
g_hash_table_insert (self->items_to_skeletons, g_strdup (item_path), skeleton);
g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (skeleton),
gkd_secret_service_get_connection (self->service),
item_path, &error);
if (error != NULL) {
g_warning ("could not register secret item on session bus: %s", error->message);
g_error_free (error);
}
g_signal_connect (skeleton, "handle-delete",
G_CALLBACK (item_method_delete), self);
g_signal_connect (skeleton, "handle-get-secret",
G_CALLBACK (item_method_get_secret), self);
g_signal_connect (skeleton, "handle-set-secret",
G_CALLBACK (item_method_set_secret), self);
}
static void
gom_application_dbus_unregister (GApplication *application,
GDBusConnection *connection,
const gchar *object_path)
{
GomApplication *self = GOM_APPLICATION (application);
if (self->skeleton != NULL)
{
if (g_dbus_interface_skeleton_has_connection (G_DBUS_INTERFACE_SKELETON (self->skeleton), connection))
g_dbus_interface_skeleton_unexport_from_connection (G_DBUS_INTERFACE_SKELETON (self->skeleton),
connection);
}
G_APPLICATION_CLASS (gom_application_parent_class)->dbus_unregister (application, connection, object_path);
}
static gboolean
gom_application_dbus_register (GApplication *application,
GDBusConnection *connection,
const gchar *object_path,
GError **error)
{
GomApplication *self = GOM_APPLICATION (application);
gboolean retval = FALSE;
if (!G_APPLICATION_CLASS (gom_application_parent_class)->dbus_register (application,
connection,
object_path,
error))
goto out;
if (!g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (self->skeleton),
connection,
object_path,
error))
goto out;
retval = TRUE;
out:
return retval;
}
void bus_acquired (GObject *object,
GAsyncResult * res,
gpointer user_data)
{
//g_debug("bus acquired");
GDBusConnection *bus;
GError *error = NULL;
bus = g_bus_get_finish (res, &error);
if (!bus) {
//g_warning ("unable to connect to the session bus: %s", error->message);
g_error_free (error);
return;
}
g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (autopilot_introspection),
bus,
AUTOPILOT_INTROSPECTION_OBJECT_PATH.c_str(),
&error);
if (error) {
//g_warning ("unable to export autopilot introspection service on dbus: %s", error->message);
g_error_free (error);
return;
}
g_signal_connect (autopilot_introspection,
"handle-get-state",
G_CALLBACK(handle_get_state),
NULL);
g_signal_connect (autopilot_introspection,
"handle-get-version",
G_CALLBACK(handle_get_version),
NULL);
g_object_unref (bus);
}
GDBusInterfaceSkeleton *
file_chooser_create (GDBusConnection *connection,
const char *dbus_name)
{
g_autoptr(GError) error = NULL;
request_by_handle = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, g_object_unref);
impl = xdp_impl_file_chooser_proxy_new_sync (connection,
G_DBUS_PROXY_FLAGS_NONE,
dbus_name,
"/org/freedesktop/portal/desktop",
NULL, &error);
if (impl == NULL)
{
g_warning ("Failed to create file chooser proxy: %s\n", error->message);
return NULL;
}
set_proxy_use_threads (G_DBUS_PROXY (impl));
file_chooser = g_object_new (file_chooser_get_type (), NULL);
g_signal_connect (impl, "open-file-response", (GCallback)handle_open_file_response, NULL);
g_signal_connect (impl, "open-files-response", (GCallback)handle_open_files_response, NULL);
g_signal_connect (impl, "save-file-response", (GCallback)handle_save_file_response, NULL);
return G_DBUS_INTERFACE_SKELETON (file_chooser);
}
static void
synce_device_dispose (GObject *obj)
{
SynceDevice *self = SYNCE_DEVICE (obj);
SynceDevicePrivate *priv = SYNCE_DEVICE_GET_PRIVATE (self);
if (priv->dispose_has_run)
return;
priv->dispose_has_run = TRUE;
#if USE_GDBUS
if (priv->interface) {
g_dbus_interface_skeleton_unexport(G_DBUS_INTERFACE_SKELETON(priv->interface));
g_object_unref(priv->interface);
}
#endif
g_io_stream_close(G_IO_STREAM(priv->conn), NULL, NULL);
g_object_unref(priv->conn);
#if HAVE_GUDEV
g_object_unref(priv->gudev_client);
#endif
g_hash_table_destroy (priv->requests);
if (G_OBJECT_CLASS (synce_device_parent_class)->dispose)
G_OBJECT_CLASS (synce_device_parent_class)->dispose (obj);
}
void
synce_device_dbus_uninit(SynceDevice *self)
{
SynceDevicePrivate *priv = SYNCE_DEVICE_GET_PRIVATE (self);
g_return_if_fail(priv->inited && !(priv->dispose_has_run));
#if !USE_GDBUS
GError *error = NULL;
DBusGConnection *system_bus = NULL;
#endif
g_message ("%s: unregistering object path '%s'", G_STRFUNC, priv->obj_path);
#if USE_GDBUS
g_dbus_interface_skeleton_unexport(G_DBUS_INTERFACE_SKELETON(priv->interface));
g_object_unref(priv->interface);
priv->interface = NULL;
#else
system_bus = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error);
if (system_bus == NULL) {
g_critical("Failed to connect to system bus: %s", error->message);
g_error_free(error);
return;
}
dbus_g_connection_unregister_g_object(system_bus, G_OBJECT(self));
dbus_g_connection_unref(system_bus);
#endif
return;
}
static void
on_bus_acquired (GDBusConnection *connection,
const gchar *name,
gpointer user_data)
{
XdpDbusContentPortal *helper;
GError *error = NULL;
helper = xdp_dbus_content_portal_skeleton_new ();
g_signal_connect (helper, "handle-open",
G_CALLBACK (handle_open), NULL);
g_signal_connect (helper, "handle-create",
G_CALLBACK (handle_create), NULL);
xdp_connection_track_name_owners (connection);
if (!g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (helper),
connection,
"/org/freedesktop/portal/content",
&error))
{
g_warning ("error: %s\n", error->message);
g_error_free (error);
}
}
static void
on_bus_acquired (GDBusConnection *connection,
const gchar *name,
gpointer user_data)
{
XdpDbusDocuments *helper;
GError *error = NULL;
helper = xdp_dbus_documents_skeleton_new ();
g_signal_connect_swapped (helper, "handle-get-mount-point", G_CALLBACK (handle_get_mount_point), NULL);
g_signal_connect_swapped (helper, "handle-add", G_CALLBACK (handle_method), portal_add);
g_signal_connect_swapped (helper, "handle-add-named", G_CALLBACK (handle_method), portal_add_named);
g_signal_connect_swapped (helper, "handle-grant-permissions", G_CALLBACK (handle_method), portal_grant_permissions);
g_signal_connect_swapped (helper, "handle-revoke-permissions", G_CALLBACK (handle_method), portal_revoke_permissions);
g_signal_connect_swapped (helper, "handle-delete", G_CALLBACK (handle_method), portal_delete);
xdg_app_connection_track_name_owners (connection);
if (!g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (helper),
connection,
"/org/freedesktop/portal/documents",
&error))
{
g_warning ("error: %s", error->message);
g_error_free (error);
}
}
GDBusInterfaceSkeleton *
trash_create (GDBusConnection *connection)
{
trash = g_object_new (trash_get_type (), NULL);
return G_DBUS_INTERFACE_SKELETON (trash);
}
/**
* bus_acquired_cb - handler to invoke when connected to the bus
* of type bus_type or NULL.
*
* @connection: The GDBusConnection to a message bus
* @bus_name : The name that is requested to be owned
* @user_data :
*
* returns:
* void
*
*/
static void
bus_acquired_cb(GDBusConnection *connection,
const gchar *bus_name,
gpointer user_data)
{
GError *pError = NULL;
gchar *obj_path = user_data;
INFO_LOG ("bus_acquired_cb ,Acquired session bus.\n");
/** Second step: Try to get a connection to the given bus. */
pSkeleton = gdbus_mcuinfo_skeleton_new();
/** Third step: Attach to dbus signals. */
(void) g_signal_connect(pSkeleton, "handle-send-mcuinfo", G_CALLBACK(method_send_mcuinfo), NULL);
/** Fourth step: Export interface skeleton. */
(void) g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(pSkeleton),
connection,
obj_path,//AUTOLINK_GDBUS_BUS_OBJECT_PATH,
&pError);
if(pError != NULL){
ERR_LOG ("bus_acquired_cb: Failed to export object. Reason: %s.\n", pError->message);
g_error_free(pError);
g_main_loop_quit(mainloop);
}
}
static gboolean
subprocess_backend_handle_create_cb (EDBusSubprocessBackend *proxy,
GDBusMethodInvocation *invocation,
const gchar *uid,
const gchar *backend_factory_type_name,
const gchar *module_filename,
ESubprocessBookFactory *subprocess_book_factory)
{
gchar *object_path = NULL;
GDBusConnection *connection;
GError *error = NULL;
connection = g_dbus_method_invocation_get_connection (invocation);
object_path = e_subprocess_factory_open_backend (
E_SUBPROCESS_FACTORY (subprocess_book_factory),
connection,
uid,
backend_factory_type_name,
module_filename,
G_DBUS_INTERFACE_SKELETON (proxy),
NULL,
&error);
if (object_path != NULL) {
e_dbus_subprocess_backend_complete_create (proxy, invocation, object_path);
g_free (object_path);
} else {
g_dbus_method_invocation_take_error (invocation, error);
}
return TRUE;
}
static void
nemo_dbus_manager_init (NemoDBusManager *self)
{
GDBusConnection *connection;
connection = g_application_get_dbus_connection (g_application_get_default ());
self->object_manager = g_dbus_object_manager_server_new ("/org/Nemo");
self->file_operations = nemo_dbus_file_operations_skeleton_new ();
g_signal_connect (self->file_operations,
"handle-copy-uris",
G_CALLBACK (handle_copy_uris),
self);
g_signal_connect (self->file_operations,
"handle-copy-file",
G_CALLBACK (handle_copy_file),
self);
g_signal_connect (self->file_operations,
"handle-empty-trash",
G_CALLBACK (handle_empty_trash),
self);
g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (self->file_operations), connection,
"/org/Nemo", NULL);
g_dbus_object_manager_server_set_connection (self->object_manager, connection);
}
static void
storaged_linux_block_bcache_init (StoragedLinuxBlockBcache *self)
{
g_dbus_interface_skeleton_set_flags (G_DBUS_INTERFACE_SKELETON (self),
G_DBUS_INTERFACE_SKELETON_FLAGS_HANDLE_METHOD_INVOCATIONS_IN_THREAD);
}
static void
manager_init (Manager *manager)
{
g_dbus_interface_skeleton_set_flags (G_DBUS_INTERFACE_SKELETON (manager),
G_DBUS_INTERFACE_SKELETON_FLAGS_HANDLE_METHOD_INVOCATIONS_IN_THREAD);
manager->cancellable = g_cancellable_new ();
}
static void bus_acquired_cb(GDBusConnection *connection, const gchar *name, gpointer user_data)
{
GError *error = NULL;
connman_agent_t *agent = user_data;
agent->path = g_strdup(AGENT_DBUS_PATH);
agent->interface = connman_interface_agent_skeleton_new();
g_signal_connect(agent->interface, "handle-request-input", G_CALLBACK(request_input_cb), agent);
g_signal_connect(agent->interface, "handle-report-error", G_CALLBACK(report_error_cb), agent);
error = NULL;
if (!g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(agent->interface), connection,
agent->path, &error))
{
g_error("Could not export agent object: %s", error->message);
g_error_free(error);
}
if (agent->registered_cb != NULL) {
agent->registered_cb(agent->registered_data);
}
g_message("Agent successfully exported");
}
