/* * Copyright © 2017-2018 Red Hat, Inc * * SPDX-License-Identifier: LGPL-2.1-or-later * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library. If not, see . * */ #include "config.h" #include "input-capture.h" #include #include #include #include "xdp-context.h" #include "xdp-dbus.h" #include "xdp-impl-dbus.h" #include "xdp-portal-config.h" #include "xdp-request.h" #include "xdp-session-persistence.h" #include "xdp-session.h" #include "xdp-utils.h" typedef struct _InputCapture InputCapture; typedef struct _InputCaptureClass InputCaptureClass; struct _InputCapture { XdpDbusInputCaptureSkeleton parent_instance; XdpContext *context; XdpDbusImplInputCapture *impl; int impl_version; }; struct _InputCaptureClass { XdpDbusInputCaptureSkeletonClass parent_class; }; static GQuark quark_request_session; GType input_capture_get_type (void) G_GNUC_CONST; static void input_capture_iface_init (XdpDbusInputCaptureIface *iface); G_DEFINE_TYPE_WITH_CODE (InputCapture, input_capture, XDP_DBUS_TYPE_INPUT_CAPTURE_SKELETON, G_IMPLEMENT_INTERFACE (XDP_DBUS_TYPE_INPUT_CAPTURE, input_capture_iface_init)); G_DEFINE_AUTOPTR_CLEANUP_FUNC (InputCapture, g_object_unref) typedef enum _InputCaptureCapabilities { INPUT_CAPTURE_CAPABILITIES_KEYBOARD = (1 << 0), INPUT_CAPTURE_CAPABILITIES_POINTER = (1 << 1), INPUT_CAPTURE_CAPABILITIES_TOUCHSCREEN = (1 << 2), INPUT_CAPTURE_CAPABILITIES_ALL = (1 << 3) - 1, } InputCaptureCapabilities; typedef enum _InputCaptureSessionState { INPUT_CAPTURE_SESSION_STATE_INIT, INPUT_CAPTURE_SESSION_STATE_STARTED, INPUT_CAPTURE_SESSION_STATE_ENABLED, INPUT_CAPTURE_SESSION_STATE_ACTIVE, INPUT_CAPTURE_SESSION_STATE_DISABLED, INPUT_CAPTURE_SESSION_STATE_CLOSED } InputCaptureSessionState; typedef struct _InputCaptureSession { XdpSession parent; int impl_version; InputCaptureSessionState state; gboolean clipboard_requested; gboolean clipboard_enabled; char *restore_token; XdpSessionPersistenceMode persist_mode; GVariant *restore_data; } InputCaptureSession; typedef struct _InputCaptureSessionClass { XdpSessionClass parent_class; } InputCaptureSessionClass; G_DEFINE_TYPE (InputCaptureSession, input_capture_session, xdp_session_get_type ()) G_DEFINE_AUTOPTR_CLEANUP_FUNC (InputCaptureSession, g_object_unref) static void input_capture_session_close (XdpSession *session) { InputCaptureSession *input_capture_session = INPUT_CAPTURE_SESSION (session); input_capture_session->state = INPUT_CAPTURE_SESSION_STATE_CLOSED; g_debug ("input capture session owned by '%s' closed", session->sender); } static void input_capture_session_finalize (GObject *object) { InputCaptureSession *input_capture_session = INPUT_CAPTURE_SESSION (object); g_clear_pointer (&input_capture_session->restore_token, g_free); g_clear_pointer (&input_capture_session->restore_data, g_variant_unref); G_OBJECT_CLASS (input_capture_session_parent_class)->finalize (object); } static void input_capture_session_init (InputCaptureSession *input_capture_session) { } static void input_capture_session_class_init (InputCaptureSessionClass *klass) { GObjectClass *object_class; XdpSessionClass *session_class; object_class = G_OBJECT_CLASS (klass); object_class->finalize = input_capture_session_finalize; session_class = (XdpSessionClass *)klass; session_class->close = input_capture_session_close; } static InputCaptureSession * input_capture_session_new (InputCapture *input_capture, GVariant *options, GDBusConnection *connection, XdpAppInfo *app_info, GError **error) { const char *session_token; XdpSession *session; InputCaptureSession *input_capture_session; GDBusConnection *impl_connection = g_dbus_proxy_get_connection (G_DBUS_PROXY (input_capture->impl)); const char *impl_dbus_name = g_dbus_proxy_get_name (G_DBUS_PROXY (input_capture->impl)); session_token = lookup_session_token (options); session = g_initable_new (input_capture_session_get_type (), NULL, error, "context", input_capture->context, "sender", xdp_app_info_get_sender (app_info), "app-id", xdp_app_info_get_id (app_info), "token", session_token, "connection", connection, "impl-connection", impl_connection, "impl-dbus-name", impl_dbus_name, NULL); if (!session) return NULL; input_capture_session = (InputCaptureSession*) session; input_capture_session->impl_version = input_capture->impl_version; g_debug ("input capture session owned by '%s' created", xdp_app_info_get_sender (app_info)); return input_capture_session; } gboolean input_capture_session_can_request_clipboard (InputCaptureSession *session) { if (session->clipboard_requested) return FALSE; if (session->impl_version < 2) return FALSE; switch (session->state) { case INPUT_CAPTURE_SESSION_STATE_INIT: return TRUE; case INPUT_CAPTURE_SESSION_STATE_STARTED: case INPUT_CAPTURE_SESSION_STATE_ENABLED: case INPUT_CAPTURE_SESSION_STATE_ACTIVE: case INPUT_CAPTURE_SESSION_STATE_DISABLED: case INPUT_CAPTURE_SESSION_STATE_CLOSED: return FALSE; } g_assert_not_reached (); } gboolean input_capture_session_is_clipboard_enabled (InputCaptureSession *session) { return session->clipboard_enabled; } void input_capture_session_clipboard_requested (InputCaptureSession *session) { session->clipboard_requested = TRUE; } gboolean input_capture_session_can_access_clipboard (InputCaptureSession *session) { return session->clipboard_enabled && session->state == INPUT_CAPTURE_SESSION_STATE_ACTIVE; } static gboolean validate_capabilities (const char *key, GVariant *value, GVariant *options, gpointer user_data, GError **error) { uint32_t types = g_variant_get_uint32 (value); if (types == 0 || (types & ~INPUT_CAPTURE_CAPABILITIES_ALL) != 0) { g_set_error (error, XDG_DESKTOP_PORTAL_ERROR, XDG_DESKTOP_PORTAL_ERROR_INVALID_ARGUMENT, "Unsupported capability: %x", types & ~INPUT_CAPTURE_CAPABILITIES_ALL); return FALSE; } return TRUE; } static void start_done (GObject *source_object, GAsyncResult *res, gpointer data); static XdpOptionKey input_capture_create_session_options[] = { { "capabilities", G_VARIANT_TYPE_UINT32, validate_capabilities }, }; static gboolean handle_create_session (XdpDbusInputCapture *object, GDBusMethodInvocation *invocation, const char *arg_parent_window, GVariant *arg_options) { InputCapture *input_capture = (InputCapture *) object; XdpRequest *request = xdp_request_from_invocation (invocation); GDBusConnection *connection = g_dbus_method_invocation_get_connection (invocation); g_autoptr(XdpDbusImplRequest) impl_request = NULL; g_autoptr(GError) error = NULL; g_auto(GVariantBuilder) options_builder = G_VARIANT_BUILDER_INIT (G_VARIANT_TYPE_VARDICT); g_autoptr(GVariant) options = NULL; XdpSession *session; REQUEST_AUTOLOCK (request); impl_request = xdp_dbus_impl_request_proxy_new_sync ( g_dbus_proxy_get_connection (G_DBUS_PROXY (input_capture->impl)), G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES, g_dbus_proxy_get_name (G_DBUS_PROXY (input_capture->impl)), request->id, NULL, &error); if (!impl_request) { g_dbus_method_invocation_return_gerror (invocation, error); return G_DBUS_METHOD_INVOCATION_HANDLED; } xdp_request_set_impl_request (request, impl_request); xdp_request_export (request, connection); if (!xdp_filter_options (arg_options, &options_builder, input_capture_create_session_options, G_N_ELEMENTS (input_capture_create_session_options), NULL, &error)) { g_dbus_method_invocation_return_gerror (invocation, error); return G_DBUS_METHOD_INVOCATION_HANDLED; } options = g_variant_ref_sink (g_variant_builder_end (&options_builder)); session = XDP_SESSION (input_capture_session_new (input_capture, arg_options, connection, request->app_info, &error)); if (!session) { g_dbus_method_invocation_return_gerror (invocation, error); return G_DBUS_METHOD_INVOCATION_HANDLED; } g_object_set_qdata_full (G_OBJECT (request), quark_request_session, g_object_ref (session), g_object_unref); g_object_set_data (G_OBJECT (request), "-xdp-input-capture", input_capture); if (input_capture->impl_version < 2) { xdp_dbus_impl_input_capture_call_create_session (input_capture->impl, request->id, session->id, session->app_id, arg_parent_window, options, NULL, start_done, g_object_ref (request)); } else { g_auto(GVariantBuilder) empty_options_builder = G_VARIANT_BUILDER_INIT (G_VARIANT_TYPE_VARDICT); g_autoptr(GVariant) results = NULL; if (!xdp_dbus_impl_input_capture_call_create_session2_sync (input_capture->impl, session->id, session->app_id, g_variant_builder_end (&empty_options_builder), &results, NULL, &error)) { xdp_session_close (session, FALSE); g_dbus_method_invocation_return_gerror (invocation, error); return G_DBUS_METHOD_INVOCATION_HANDLED; } xdp_dbus_impl_input_capture_call_start (input_capture->impl, request->id, session->id, session->app_id, arg_parent_window, options, NULL, start_done, g_object_ref (request)); } G_GNUC_BEGIN_IGNORE_DEPRECATIONS xdp_dbus_input_capture_complete_create_session (object, invocation, request->id); G_GNUC_END_IGNORE_DEPRECATIONS return G_DBUS_METHOD_INVOCATION_HANDLED; } static XdpOptionKey input_capture_create_session2_options[] = { }; static gboolean handle_create_session2 (XdpDbusInputCapture *object, GDBusMethodInvocation *invocation, GVariant *arg_options) { InputCapture *input_capture = (InputCapture *) object; XdpAppInfo *app_info = xdp_invocation_get_app_info (invocation); GDBusConnection *connection = g_dbus_method_invocation_get_connection (invocation); XdpSession *session; g_auto(GVariantBuilder) options_builder = G_VARIANT_BUILDER_INIT (G_VARIANT_TYPE_VARDICT); g_autoptr(GVariant) options = NULL; g_autoptr(GVariant) results = NULL; g_autoptr(GError) error = NULL; g_auto(GVariantBuilder) results_builder = G_VARIANT_BUILDER_INIT (G_VARIANT_TYPE_VARDICT); if (input_capture->impl_version < 2) return G_DBUS_METHOD_INVOCATION_UNHANDLED; if (!xdp_filter_options (arg_options, &options_builder, input_capture_create_session2_options, G_N_ELEMENTS (input_capture_create_session2_options), NULL, &error)) { g_dbus_method_invocation_return_gerror (invocation, error); return G_DBUS_METHOD_INVOCATION_HANDLED; } options = g_variant_ref_sink (g_variant_builder_end (&options_builder)); session = XDP_SESSION (input_capture_session_new (input_capture, arg_options, connection, app_info, &error)); if (!session) { g_dbus_method_invocation_return_gerror (invocation, error); return G_DBUS_METHOD_INVOCATION_HANDLED; } if (!xdp_dbus_impl_input_capture_call_create_session2_sync (input_capture->impl, session->id, session->app_id, options, &results, NULL, &error)) { xdp_session_close (session, FALSE); g_dbus_method_invocation_return_gerror (invocation, error); return G_DBUS_METHOD_INVOCATION_HANDLED; } if (!xdp_session_export (session, &error)) { xdp_session_close (session, FALSE); g_dbus_method_invocation_return_gerror (invocation, error); return G_DBUS_METHOD_INVOCATION_HANDLED; } xdp_session_register (session); g_variant_builder_add (&results_builder, "{sv}", "session_handle", g_variant_new_object_path (session->id)); xdp_dbus_input_capture_complete_create_session2 (object, invocation, g_variant_builder_end (&results_builder)); return G_DBUS_METHOD_INVOCATION_HANDLED; } static void start_done (GObject *source_object, GAsyncResult *res, gpointer data) { InputCapture *input_capture; XdpDbusImplInputCapture *impl = XDP_DBUS_IMPL_INPUT_CAPTURE (source_object); g_autoptr(XdpRequest) request = XDP_REQUEST (data); XdpSession *session; g_autoptr(GVariant) results = NULL; g_autoptr(GError) error = NULL; gboolean should_close_session = FALSE; uint32_t response = XDG_DESKTOP_PORTAL_RESPONSE_OTHER; g_auto(GVariantBuilder) results_builder = G_VARIANT_BUILDER_INIT (G_VARIANT_TYPE_VARDICT); REQUEST_AUTOLOCK (request); session = g_object_get_qdata (G_OBJECT (request), quark_request_session); SESSION_AUTOLOCK_UNREF (g_object_ref (session)); g_object_set_qdata (G_OBJECT (request), quark_request_session, NULL); input_capture = g_object_get_data (G_OBJECT (request), "-xdp-input-capture"); if (input_capture->impl_version < 2) { if (!xdp_dbus_impl_input_capture_call_create_session_finish (impl, &response, &results, res, &error)) { g_dbus_error_strip_remote_error (error); g_warning ("A backend call failed: %s", error->message); } } else { if (!xdp_dbus_impl_input_capture_call_start_finish (impl, &response, &results, res, &error)) { g_dbus_error_strip_remote_error (error); g_warning ("A backend call failed: %s", error->message); } } /* For the legacy CreateSession we have to take care of exporting it now */ if (!session->exported) { if (!xdp_session_export (session, &error)) { g_warning ("Failed to export session: %s", error->message); response = XDG_DESKTOP_PORTAL_RESPONSE_OTHER; should_close_session = TRUE; goto out; } xdp_session_register (session); } if (request->exported && response == XDG_DESKTOP_PORTAL_RESPONSE_SUCCESS) { InputCaptureSession *input_capture_session = INPUT_CAPTURE_SESSION (session); uint32_t capabilities = 0; gboolean clipboard_enabled = FALSE; input_capture_session->state = INPUT_CAPTURE_SESSION_STATE_STARTED; g_variant_builder_add (&results_builder, "{sv}", "session_handle", g_variant_new_object_path (session->id)); if (!g_variant_lookup (results, "capabilities", "u", &capabilities)) { g_warning ("Impl did not set capabilities"); response = XDG_DESKTOP_PORTAL_RESPONSE_OTHER; should_close_session = TRUE; goto out; } g_variant_builder_add (&results_builder, "{sv}", "capabilities", g_variant_new_uint32 (capabilities)); if (g_variant_lookup (results, "clipboard_enabled", "b", &clipboard_enabled)) { input_capture_session->clipboard_enabled = clipboard_enabled; g_variant_builder_add (&results_builder, "{sv}", "clipboard_enabled", g_variant_new_boolean (clipboard_enabled)); } xdp_session_persistence_replace_restore_data_with_token (XDP_SESSION (input_capture_session), INPUT_CAPTURE_PERMISSION_TABLE, &results, &input_capture_session->persist_mode, &input_capture_session->restore_token, &input_capture_session->restore_data); if (input_capture_session->restore_token) { g_variant_builder_add (&results_builder, "{sv}", "restore_token", g_variant_new_string (input_capture_session->restore_token)); } } else { should_close_session = TRUE; } out: if (request->exported) { xdp_dbus_request_emit_response (XDP_DBUS_REQUEST (request), response, g_variant_builder_end (&results_builder)); xdp_request_unexport (request); } if (should_close_session) xdp_session_close (session, FALSE); } static gboolean replace_input_capture_restore_token_with_data (XdpSession *session, GVariant **in_out_options, GError **error) { InputCaptureSession *input_capture_session = INPUT_CAPTURE_SESSION (session); g_autoptr(GVariant) options = NULL; XdpSessionPersistenceMode persist_mode; options = *in_out_options; if (!g_variant_lookup (options, "persist_mode", "u", &persist_mode)) persist_mode = XDP_SESSION_PERSISTENCE_MODE_NONE; input_capture_session->persist_mode = persist_mode; xdp_session_persistence_replace_restore_token_with_data (session, INPUT_CAPTURE_PERMISSION_TABLE, in_out_options, &input_capture_session->restore_token); return TRUE; } static gboolean validate_restore_token (const char *key, GVariant *value, GVariant *options, gpointer user_data, GError **error) { const char *restore_token = g_variant_get_string (value, NULL); return xdp_session_persistence_validate_restore_token (restore_token, error); } static gboolean validate_persist_mode (const char *key, GVariant *value, GVariant *options, gpointer user_data, GError **error) { return xdp_session_persistence_validate_persist_mode (g_variant_get_uint32 (value), error); } static XdpOptionKey input_capture_start_options[] = { { "capabilities", G_VARIANT_TYPE_UINT32, validate_capabilities }, { "restore_token", G_VARIANT_TYPE_STRING, validate_restore_token }, { "persist_mode", G_VARIANT_TYPE_UINT32, validate_persist_mode }, }; static gboolean handle_start (XdpDbusInputCapture *object, GDBusMethodInvocation *invocation, const char *arg_session_handle, const char *arg_parent_window, GVariant *arg_options) { InputCapture *input_capture = (InputCapture *) object; XdpRequest *request = xdp_request_from_invocation (invocation); XdpSession *session; InputCaptureSession *input_capture_session; g_autoptr(XdpDbusImplRequest) impl_request = NULL; g_auto(GVariantBuilder) options_builder = G_VARIANT_BUILDER_INIT (G_VARIANT_TYPE_VARDICT); g_autoptr(GVariant) options = NULL; g_autoptr(GError) error = NULL; if (input_capture->impl_version < 2) return G_DBUS_METHOD_INVOCATION_UNHANDLED; REQUEST_AUTOLOCK (request); session = xdp_session_from_request (arg_session_handle, request); if (!session) { g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_ACCESS_DENIED, "Invalid session"); return G_DBUS_METHOD_INVOCATION_HANDLED; } SESSION_AUTOLOCK_UNREF (session); if (!IS_INPUT_CAPTURE_SESSION (session)) { g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Invalid session"); return G_DBUS_METHOD_INVOCATION_HANDLED; } input_capture_session = INPUT_CAPTURE_SESSION (session); switch (input_capture_session->state) { case INPUT_CAPTURE_SESSION_STATE_STARTED: case INPUT_CAPTURE_SESSION_STATE_ENABLED: case INPUT_CAPTURE_SESSION_STATE_ACTIVE: case INPUT_CAPTURE_SESSION_STATE_DISABLED: case INPUT_CAPTURE_SESSION_STATE_CLOSED: g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Invalid session"); return G_DBUS_METHOD_INVOCATION_HANDLED; case INPUT_CAPTURE_SESSION_STATE_INIT: break; } impl_request = xdp_dbus_impl_request_proxy_new_sync ( g_dbus_proxy_get_connection (G_DBUS_PROXY (input_capture->impl)), G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES, g_dbus_proxy_get_name (G_DBUS_PROXY (input_capture->impl)), request->id, NULL, &error); if (!impl_request) { g_dbus_method_invocation_return_gerror (invocation, error); return G_DBUS_METHOD_INVOCATION_HANDLED; } xdp_request_set_impl_request (request, impl_request); xdp_request_export (request, g_dbus_method_invocation_get_connection (invocation)); if (!xdp_filter_options (arg_options, &options_builder, input_capture_start_options, G_N_ELEMENTS (input_capture_start_options), NULL, &error)) { g_dbus_method_invocation_return_gerror (invocation, error); return G_DBUS_METHOD_INVOCATION_HANDLED; } options = g_variant_ref_sink (g_variant_builder_end (&options_builder)); /* If 'restore_token' is passed, lookup the corresponding data in the * permission store and / or the GHashTable with transient permissions. * Portal implementations do not have access to the restore token. */ if (!replace_input_capture_restore_token_with_data (session, &options, &error)) { g_dbus_method_invocation_return_gerror (invocation, error); return G_DBUS_METHOD_INVOCATION_HANDLED; } g_object_set_qdata_full (G_OBJECT (request), quark_request_session, g_object_ref (session), g_object_unref); g_object_set_data (G_OBJECT (request), "-xdp-input-capture", input_capture); xdp_dbus_impl_input_capture_call_start (input_capture->impl, request->id, arg_session_handle, session->app_id, arg_parent_window, options, NULL, start_done, g_object_ref (request)); xdp_dbus_input_capture_complete_start (object, invocation, request->id); return G_DBUS_METHOD_INVOCATION_HANDLED; } static void get_zones_done (GObject *source_object, GAsyncResult *res, gpointer data) { XdpDbusImplInputCapture *impl = (XdpDbusImplInputCapture *) source_object; g_autoptr(GVariant) results = NULL; g_autoptr(XdpRequest) request = NULL; g_autoptr(GError) error = NULL; XdpSession *session; gboolean should_close_session; uint32_t response = XDG_DESKTOP_PORTAL_RESPONSE_OTHER; request = XDP_REQUEST (data); REQUEST_AUTOLOCK (request); session = g_object_get_qdata (G_OBJECT (request), quark_request_session); SESSION_AUTOLOCK_UNREF (g_object_ref (session)); g_object_set_qdata (G_OBJECT (request), quark_request_session, NULL); if (!xdp_dbus_impl_input_capture_call_get_zones_finish (impl, &response, &results, res, &error)) { g_dbus_error_strip_remote_error (error); g_warning ("A backend call failed: %s", error->message); } should_close_session = !request->exported || response != XDG_DESKTOP_PORTAL_RESPONSE_SUCCESS; if (request->exported) { if (!results) { g_auto(GVariantBuilder) results_builder = G_VARIANT_BUILDER_INIT (G_VARIANT_TYPE_VARDICT); results = g_variant_ref_sink (g_variant_builder_end (&results_builder)); } xdp_dbus_request_emit_response (XDP_DBUS_REQUEST (request), response, results); xdp_request_unexport (request); } if (should_close_session) { xdp_session_close (session, TRUE); } } static XdpOptionKey input_capture_get_zones_options[] = { }; static gboolean handle_get_zones (XdpDbusInputCapture *object, GDBusMethodInvocation *invocation, const char *arg_session_handle, GVariant *arg_options) { InputCapture *input_capture = (InputCapture *) object; XdpRequest *request = xdp_request_from_invocation (invocation); g_autoptr(XdpDbusImplRequest) impl_request = NULL; InputCaptureSession *input_capture_session; g_autoptr(GError) error = NULL; g_auto(GVariantBuilder) options_builder = G_VARIANT_BUILDER_INIT (G_VARIANT_TYPE_VARDICT); g_autoptr(GVariant) options = NULL; XdpSession *session; REQUEST_AUTOLOCK (request); session = xdp_session_from_request (arg_session_handle, request); if (!session) { g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_ACCESS_DENIED, "Invalid session"); return G_DBUS_METHOD_INVOCATION_HANDLED; } SESSION_AUTOLOCK_UNREF (session); if (!IS_INPUT_CAPTURE_SESSION (session)) { g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Invalid session"); return G_DBUS_METHOD_INVOCATION_HANDLED; } input_capture_session = INPUT_CAPTURE_SESSION (session); switch (input_capture_session->state) { case INPUT_CAPTURE_SESSION_STATE_STARTED: case INPUT_CAPTURE_SESSION_STATE_ENABLED: case INPUT_CAPTURE_SESSION_STATE_ACTIVE: case INPUT_CAPTURE_SESSION_STATE_DISABLED: break; case INPUT_CAPTURE_SESSION_STATE_INIT: case INPUT_CAPTURE_SESSION_STATE_CLOSED: g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Invalid session"); return G_DBUS_METHOD_INVOCATION_HANDLED; } impl_request = xdp_dbus_impl_request_proxy_new_sync ( g_dbus_proxy_get_connection (G_DBUS_PROXY (input_capture->impl)), G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES, g_dbus_proxy_get_name (G_DBUS_PROXY (input_capture->impl)), request->id, NULL, &error); if (!impl_request) { g_dbus_method_invocation_return_gerror (invocation, error); return G_DBUS_METHOD_INVOCATION_HANDLED; } xdp_request_set_impl_request (request, impl_request); xdp_request_export (request, g_dbus_method_invocation_get_connection (invocation)); if (!xdp_filter_options (arg_options, &options_builder, input_capture_get_zones_options, G_N_ELEMENTS (input_capture_get_zones_options), NULL, &error)) { g_dbus_method_invocation_return_gerror (invocation, error); return G_DBUS_METHOD_INVOCATION_HANDLED; } options = g_variant_ref_sink (g_variant_builder_end (&options_builder)); g_object_set_qdata_full (G_OBJECT (request), quark_request_session, g_object_ref (session), g_object_unref); xdp_dbus_impl_input_capture_call_get_zones (input_capture->impl, request->id, arg_session_handle, xdp_app_info_get_id (request->app_info), options, NULL, get_zones_done, g_object_ref (request)); xdp_dbus_input_capture_complete_get_zones (object, invocation, request->id); return G_DBUS_METHOD_INVOCATION_HANDLED; } static void set_pointer_barriers_done (GObject *source_object, GAsyncResult *res, gpointer data) { XdpDbusImplInputCapture *impl = (XdpDbusImplInputCapture *) source_object; g_autoptr(GVariant) results = NULL; g_autoptr(XdpRequest) request = NULL; g_autoptr(GError) error = NULL; gboolean should_close_session; XdpSession *session; uint32_t response = XDG_DESKTOP_PORTAL_RESPONSE_OTHER; request = XDP_REQUEST (data); REQUEST_AUTOLOCK (request); session = g_object_get_qdata (G_OBJECT (request), quark_request_session); SESSION_AUTOLOCK_UNREF (g_object_ref (session)); g_object_set_qdata (G_OBJECT (request), quark_request_session, NULL); if (!xdp_dbus_impl_input_capture_call_set_pointer_barriers_finish (impl, &response, &results, res, &error)) { g_dbus_error_strip_remote_error (error); g_warning ("A backend call failed: %s", error->message); g_clear_error (&error); } should_close_session = !request->exported || response != XDG_DESKTOP_PORTAL_RESPONSE_SUCCESS; if (request->exported) { if (!results) { g_auto(GVariantBuilder) results_builder = G_VARIANT_BUILDER_INIT (G_VARIANT_TYPE_VARDICT); results = g_variant_ref_sink (g_variant_builder_end (&results_builder)); } xdp_dbus_request_emit_response (XDP_DBUS_REQUEST (request), response, results); xdp_request_unexport (request); } if (should_close_session) xdp_session_close (session, TRUE); } static XdpOptionKey input_capture_set_pointer_barriers_options[] = { }; static gboolean handle_set_pointer_barriers (XdpDbusInputCapture *object, GDBusMethodInvocation *invocation, const char *arg_session_handle, GVariant *arg_options, GVariant *arg_barriers, uint32_t arg_zone_set) { InputCapture *input_capture = (InputCapture *) object; XdpRequest *request = xdp_request_from_invocation (invocation); g_autoptr(XdpDbusImplRequest) impl_request = NULL; InputCaptureSession *input_capture_session; g_autoptr(GError) error = NULL; g_auto(GVariantBuilder) options_builder = G_VARIANT_BUILDER_INIT (G_VARIANT_TYPE_VARDICT); g_autoptr(GVariant) options = NULL; XdpSession *session; REQUEST_AUTOLOCK (request); session = xdp_session_from_request (arg_session_handle, request); if (!session) { g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_ACCESS_DENIED, "Invalid session"); return G_DBUS_METHOD_INVOCATION_HANDLED; } SESSION_AUTOLOCK_UNREF (session); if (!IS_INPUT_CAPTURE_SESSION (session)) { g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Invalid session"); return G_DBUS_METHOD_INVOCATION_HANDLED; } input_capture_session = INPUT_CAPTURE_SESSION (session); switch (input_capture_session->state) { case INPUT_CAPTURE_SESSION_STATE_STARTED: case INPUT_CAPTURE_SESSION_STATE_ENABLED: case INPUT_CAPTURE_SESSION_STATE_ACTIVE: case INPUT_CAPTURE_SESSION_STATE_DISABLED: break; case INPUT_CAPTURE_SESSION_STATE_INIT: case INPUT_CAPTURE_SESSION_STATE_CLOSED: g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Invalid session"); return G_DBUS_METHOD_INVOCATION_HANDLED; } impl_request = xdp_dbus_impl_request_proxy_new_sync ( g_dbus_proxy_get_connection (G_DBUS_PROXY (input_capture->impl)), G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES, g_dbus_proxy_get_name (G_DBUS_PROXY (input_capture->impl)), request->id, NULL, &error); if (!impl_request) { g_dbus_method_invocation_return_gerror (invocation, error); return G_DBUS_METHOD_INVOCATION_HANDLED; } xdp_request_set_impl_request (request, impl_request); xdp_request_export (request, g_dbus_method_invocation_get_connection (invocation)); if (!xdp_filter_options (arg_options, &options_builder, input_capture_set_pointer_barriers_options, G_N_ELEMENTS (input_capture_set_pointer_barriers_options), NULL, &error)) { g_dbus_method_invocation_return_gerror (invocation, error); return G_DBUS_METHOD_INVOCATION_HANDLED; } options = g_variant_ref_sink (g_variant_builder_end (&options_builder)); g_object_set_qdata_full (G_OBJECT (request), quark_request_session, g_object_ref (session), g_object_unref); xdp_dbus_impl_input_capture_call_set_pointer_barriers (input_capture->impl, request->id, arg_session_handle, xdp_app_info_get_id (request->app_info), options, arg_barriers, /* FIXME: validation? */ arg_zone_set, /* FIXME: validation? */ NULL, set_pointer_barriers_done, g_object_ref (request)); xdp_dbus_input_capture_complete_set_pointer_barriers (object, invocation, request->id); return G_DBUS_METHOD_INVOCATION_HANDLED; } static XdpOptionKey input_capture_enable_options[] = { }; static gboolean handle_enable (XdpDbusInputCapture *object, GDBusMethodInvocation *invocation, const char *arg_session_handle, GVariant *arg_options) { InputCapture *input_capture = (InputCapture *) object; XdpAppInfo *app_info = xdp_invocation_get_app_info (invocation); XdpSession *session; InputCaptureSession *input_capture_session; g_autoptr(GError) error = NULL; g_auto(GVariantBuilder) options_builder = G_VARIANT_BUILDER_INIT (G_VARIANT_TYPE_VARDICT); session = xdp_session_from_app_info (arg_session_handle, app_info); if (!session) { g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_ACCESS_DENIED, "Invalid session"); return G_DBUS_METHOD_INVOCATION_HANDLED; } SESSION_AUTOLOCK_UNREF (session); if (!IS_INPUT_CAPTURE_SESSION (session)) { g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Invalid session"); return G_DBUS_METHOD_INVOCATION_HANDLED; } input_capture_session = INPUT_CAPTURE_SESSION (session); switch (input_capture_session->state) { case INPUT_CAPTURE_SESSION_STATE_STARTED: g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Not connected to EIS"); return G_DBUS_METHOD_INVOCATION_HANDLED; case INPUT_CAPTURE_SESSION_STATE_ENABLED: case INPUT_CAPTURE_SESSION_STATE_ACTIVE: case INPUT_CAPTURE_SESSION_STATE_DISABLED: break; case INPUT_CAPTURE_SESSION_STATE_INIT: case INPUT_CAPTURE_SESSION_STATE_CLOSED: g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Invalid session"); return G_DBUS_METHOD_INVOCATION_HANDLED; } if (!xdp_filter_options (arg_options, &options_builder, input_capture_enable_options, G_N_ELEMENTS (input_capture_enable_options), NULL, &error)) { g_dbus_method_invocation_return_gerror (invocation, error); return G_DBUS_METHOD_INVOCATION_HANDLED; } input_capture_session->state = INPUT_CAPTURE_SESSION_STATE_ENABLED; /* Let's be lenient and make Enable() a noop for anything but a disabled * session. */ switch (input_capture_session->state) { case INPUT_CAPTURE_SESSION_STATE_ENABLED: case INPUT_CAPTURE_SESSION_STATE_ACTIVE: break; case INPUT_CAPTURE_SESSION_STATE_DISABLED: input_capture_session->state = INPUT_CAPTURE_SESSION_STATE_ENABLED; break; case INPUT_CAPTURE_SESSION_STATE_INIT: case INPUT_CAPTURE_SESSION_STATE_STARTED: case INPUT_CAPTURE_SESSION_STATE_CLOSED: /* ignore, handled above */ g_assert_not_reached (); } xdp_dbus_impl_input_capture_call_enable (input_capture->impl, arg_session_handle, xdp_app_info_get_id (app_info), g_variant_builder_end (&options_builder), NULL, NULL, NULL); xdp_dbus_input_capture_complete_enable (object, invocation); return G_DBUS_METHOD_INVOCATION_HANDLED; } static XdpOptionKey input_capture_disable_options[] = { }; static gboolean handle_disable (XdpDbusInputCapture *object, GDBusMethodInvocation *invocation, const char *arg_session_handle, GVariant *arg_options) { InputCapture *input_capture = (InputCapture *) object; XdpAppInfo *app_info = xdp_invocation_get_app_info (invocation); XdpSession *session; InputCaptureSession *input_capture_session; g_autoptr(GError) error = NULL; g_auto(GVariantBuilder) options_builder = G_VARIANT_BUILDER_INIT (G_VARIANT_TYPE_VARDICT); session = xdp_session_from_app_info (arg_session_handle, app_info); if (!session) { g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_ACCESS_DENIED, "Invalid session"); return G_DBUS_METHOD_INVOCATION_HANDLED; } SESSION_AUTOLOCK_UNREF (session); if (!IS_INPUT_CAPTURE_SESSION (session)) { g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Invalid session"); return G_DBUS_METHOD_INVOCATION_HANDLED; } input_capture_session = INPUT_CAPTURE_SESSION (session); switch (input_capture_session->state) { case INPUT_CAPTURE_SESSION_STATE_STARTED: g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Not connected to EIS"); return G_DBUS_METHOD_INVOCATION_HANDLED; case INPUT_CAPTURE_SESSION_STATE_ENABLED: case INPUT_CAPTURE_SESSION_STATE_ACTIVE: case INPUT_CAPTURE_SESSION_STATE_DISABLED: break; case INPUT_CAPTURE_SESSION_STATE_INIT: case INPUT_CAPTURE_SESSION_STATE_CLOSED: g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Invalid session"); return G_DBUS_METHOD_INVOCATION_HANDLED; } if (!xdp_filter_options (arg_options, &options_builder, input_capture_disable_options, G_N_ELEMENTS (input_capture_disable_options), NULL, &error)) { g_dbus_method_invocation_return_gerror (invocation, error); return G_DBUS_METHOD_INVOCATION_HANDLED; } /* We need to be lenient, a caller may call Disable() before processing a * Disabled signal. So we pretend everything's ok but only * update our internal state in the right transitions. */ switch (input_capture_session->state) { case INPUT_CAPTURE_SESSION_STATE_ENABLED: case INPUT_CAPTURE_SESSION_STATE_ACTIVE: input_capture_session->state = INPUT_CAPTURE_SESSION_STATE_DISABLED; break; case INPUT_CAPTURE_SESSION_STATE_DISABLED: break; case INPUT_CAPTURE_SESSION_STATE_INIT: case INPUT_CAPTURE_SESSION_STATE_STARTED: case INPUT_CAPTURE_SESSION_STATE_CLOSED: /* ignore, handled above */ g_assert_not_reached (); } xdp_dbus_impl_input_capture_call_disable (input_capture->impl, arg_session_handle, xdp_app_info_get_id (app_info), g_variant_builder_end (&options_builder), NULL, NULL, NULL); xdp_dbus_input_capture_complete_disable (object, invocation); return G_DBUS_METHOD_INVOCATION_HANDLED; } static XdpOptionKey input_capture_release_options[] = { { "cursor_position", (const GVariantType *)"(dd)", NULL }, { "activation_id", G_VARIANT_TYPE_UINT32, NULL }, }; static gboolean handle_release (XdpDbusInputCapture *object, GDBusMethodInvocation *invocation, const char *arg_session_handle, GVariant *arg_options) { InputCapture *input_capture = (InputCapture *) object; XdpAppInfo *app_info = xdp_invocation_get_app_info (invocation); XdpSession *session; InputCaptureSession *input_capture_session; g_autoptr(GError) error = NULL; g_auto(GVariantBuilder) options_builder = G_VARIANT_BUILDER_INIT (G_VARIANT_TYPE_VARDICT); session = xdp_session_from_app_info (arg_session_handle, app_info); if (!session) { g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_ACCESS_DENIED, "Invalid session"); return G_DBUS_METHOD_INVOCATION_HANDLED; } SESSION_AUTOLOCK_UNREF (session); if (!IS_INPUT_CAPTURE_SESSION (session)) { g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Invalid session"); return G_DBUS_METHOD_INVOCATION_HANDLED; } input_capture_session = INPUT_CAPTURE_SESSION (session); switch (input_capture_session->state) { case INPUT_CAPTURE_SESSION_STATE_STARTED: g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Not connected to EIS"); return G_DBUS_METHOD_INVOCATION_HANDLED; case INPUT_CAPTURE_SESSION_STATE_ENABLED: case INPUT_CAPTURE_SESSION_STATE_ACTIVE: case INPUT_CAPTURE_SESSION_STATE_DISABLED: break; case INPUT_CAPTURE_SESSION_STATE_INIT: case INPUT_CAPTURE_SESSION_STATE_CLOSED: g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Invalid session"); return G_DBUS_METHOD_INVOCATION_HANDLED; } if (!xdp_filter_options (arg_options, &options_builder, input_capture_release_options, G_N_ELEMENTS (input_capture_release_options), NULL, &error)) { g_dbus_method_invocation_return_gerror (invocation, error); return G_DBUS_METHOD_INVOCATION_HANDLED; } /* We need to be lenient, a caller may call Release() before processing a * Deactivated/Disabled signal. So we pretend everything's ok but only * update our internal state in the right transitions. */ switch (input_capture_session->state) { case INPUT_CAPTURE_SESSION_STATE_ENABLED: break; case INPUT_CAPTURE_SESSION_STATE_ACTIVE: input_capture_session->state = INPUT_CAPTURE_SESSION_STATE_ENABLED; break; case INPUT_CAPTURE_SESSION_STATE_DISABLED: break; case INPUT_CAPTURE_SESSION_STATE_INIT: case INPUT_CAPTURE_SESSION_STATE_STARTED: case INPUT_CAPTURE_SESSION_STATE_CLOSED: /* ignore, handled above */ g_assert_not_reached (); } xdp_dbus_impl_input_capture_call_release (input_capture->impl, arg_session_handle, xdp_app_info_get_id (app_info), g_variant_builder_end (&options_builder), NULL, NULL, NULL); xdp_dbus_input_capture_complete_release (object, invocation); return G_DBUS_METHOD_INVOCATION_HANDLED; } static gboolean handle_connect_to_eis (XdpDbusInputCapture *object, GDBusMethodInvocation *invocation, GUnixFDList *in_fd_list, const char *arg_session_handle, GVariant *arg_options) { InputCapture *input_capture = (InputCapture *) object; XdpAppInfo *app_info = xdp_invocation_get_app_info (invocation); XdpSession *session; InputCaptureSession *input_capture_session; g_autoptr(GUnixFDList) out_fd_list = NULL; g_autoptr(GError) error = NULL; g_auto(GVariantBuilder) empty = G_VARIANT_BUILDER_INIT (G_VARIANT_TYPE_VARDICT); g_autoptr(GVariant) fd = NULL; session = xdp_session_from_app_info (arg_session_handle, app_info); if (!session) { g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_ACCESS_DENIED, "Invalid session"); return G_DBUS_METHOD_INVOCATION_HANDLED; } SESSION_AUTOLOCK_UNREF (session); if (!IS_INPUT_CAPTURE_SESSION (session)) { g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_ACCESS_DENIED, "Invalid session"); return G_DBUS_METHOD_INVOCATION_HANDLED; } input_capture_session = INPUT_CAPTURE_SESSION (session); switch (input_capture_session->state) { case INPUT_CAPTURE_SESSION_STATE_STARTED: break; case INPUT_CAPTURE_SESSION_STATE_ENABLED: case INPUT_CAPTURE_SESSION_STATE_ACTIVE: case INPUT_CAPTURE_SESSION_STATE_DISABLED: g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Already connected"); return G_DBUS_METHOD_INVOCATION_HANDLED; case INPUT_CAPTURE_SESSION_STATE_INIT: case INPUT_CAPTURE_SESSION_STATE_CLOSED: g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Invalid session"); return G_DBUS_METHOD_INVOCATION_HANDLED; } if (!xdp_dbus_impl_input_capture_call_connect_to_eis_sync (input_capture->impl, arg_session_handle, xdp_app_info_get_id (app_info), g_variant_builder_end (&empty), in_fd_list, &fd, &out_fd_list, NULL, &error)) { g_warning ("Failed to ConnectToEIS: %s", error->message); out_fd_list = g_unix_fd_list_new (); } input_capture_session->state = INPUT_CAPTURE_SESSION_STATE_DISABLED; xdp_dbus_input_capture_complete_connect_to_eis (object, invocation, out_fd_list, fd); return G_DBUS_METHOD_INVOCATION_HANDLED; } static void input_capture_iface_init (XdpDbusInputCaptureIface *iface) { iface->handle_create_session = handle_create_session; iface->handle_create_session2 = handle_create_session2; iface->handle_start = handle_start; iface->handle_get_zones = handle_get_zones; iface->handle_set_pointer_barriers = handle_set_pointer_barriers; iface->handle_connect_to_eis = handle_connect_to_eis; iface->handle_enable = handle_enable; iface->handle_disable = handle_disable; iface->handle_release = handle_release; } static void pass_signal (XdpDbusImplInputCapture *impl, const char *signal_name, const char *session_id, GVariant *options) { GDBusConnection *connection = g_dbus_proxy_get_connection (G_DBUS_PROXY (impl)); g_autoptr(XdpSession) session = xdp_session_lookup (session_id); g_dbus_connection_emit_signal (connection, session->sender, DESKTOP_DBUS_PATH, INPUT_CAPTURE_DBUS_IFACE, signal_name, g_variant_new ("(o@a{sv})", session_id, options), NULL); } static void on_disabled_cb (XdpDbusImplInputCapture *impl, const char *session_id, GVariant *options, gpointer data) { g_autoptr(XdpSession) session = xdp_session_lookup (session_id); InputCaptureSession *input_capture_session; if (!IS_INPUT_CAPTURE_SESSION (session)) { g_critical ("Invalid session type for signal"); return; } input_capture_session = (InputCaptureSession*)session; switch (input_capture_session->state) { case INPUT_CAPTURE_SESSION_STATE_STARTED: break; case INPUT_CAPTURE_SESSION_STATE_ENABLED: case INPUT_CAPTURE_SESSION_STATE_ACTIVE: pass_signal (impl, "Disabled", session_id, options); input_capture_session->state = INPUT_CAPTURE_SESSION_STATE_DISABLED; break; case INPUT_CAPTURE_SESSION_STATE_DISABLED: case INPUT_CAPTURE_SESSION_STATE_INIT: case INPUT_CAPTURE_SESSION_STATE_CLOSED: break; } } static void on_activated_cb (XdpDbusImplInputCapture *impl, const char *session_id, GVariant *options, gpointer data) { g_autoptr(XdpSession) session = xdp_session_lookup (session_id); InputCaptureSession *input_capture_session; if (!IS_INPUT_CAPTURE_SESSION (session)) { g_critical ("Invalid session type for signal"); return; } input_capture_session = (InputCaptureSession*)session; switch (input_capture_session->state) { case INPUT_CAPTURE_SESSION_STATE_STARTED: break; case INPUT_CAPTURE_SESSION_STATE_ENABLED: pass_signal (impl, "Activated", session_id, options); input_capture_session->state = INPUT_CAPTURE_SESSION_STATE_ACTIVE; break; case INPUT_CAPTURE_SESSION_STATE_ACTIVE: case INPUT_CAPTURE_SESSION_STATE_DISABLED: case INPUT_CAPTURE_SESSION_STATE_INIT: case INPUT_CAPTURE_SESSION_STATE_CLOSED: break; } } static void on_deactivated_cb (XdpDbusImplInputCapture *impl, const char *session_id, GVariant *options, gpointer data) { g_autoptr(XdpSession) session = xdp_session_lookup (session_id); InputCaptureSession *input_capture_session; if (!IS_INPUT_CAPTURE_SESSION (session)) { g_critical ("Invalid session type for signal"); return; } input_capture_session = (InputCaptureSession*)session; switch (input_capture_session->state) { case INPUT_CAPTURE_SESSION_STATE_STARTED: case INPUT_CAPTURE_SESSION_STATE_ENABLED: break; case INPUT_CAPTURE_SESSION_STATE_ACTIVE: pass_signal (impl, "Deactivated", session_id, options); input_capture_session->state = INPUT_CAPTURE_SESSION_STATE_ENABLED; break; case INPUT_CAPTURE_SESSION_STATE_DISABLED: case INPUT_CAPTURE_SESSION_STATE_INIT: case INPUT_CAPTURE_SESSION_STATE_CLOSED: break; } } static void on_zones_changed_cb (XdpDbusImplInputCapture *impl, const char *session_id, GVariant *options, gpointer data) { g_autoptr(XdpSession) session = xdp_session_lookup (session_id); InputCaptureSession *input_capture_session; if (!IS_INPUT_CAPTURE_SESSION (session)) { g_critical ("Invalid session type for signal"); return; } input_capture_session = (InputCaptureSession*)session; switch (input_capture_session->state) { case INPUT_CAPTURE_SESSION_STATE_STARTED: case INPUT_CAPTURE_SESSION_STATE_ENABLED: case INPUT_CAPTURE_SESSION_STATE_ACTIVE: case INPUT_CAPTURE_SESSION_STATE_DISABLED: pass_signal (impl, "ZonesChanged", session_id, options); break; case INPUT_CAPTURE_SESSION_STATE_INIT: case INPUT_CAPTURE_SESSION_STATE_CLOSED: break; } } static void input_capture_dispose (GObject *object) { InputCapture *input_capture = (InputCapture *) object; g_clear_object (&input_capture->impl); G_OBJECT_CLASS (input_capture_parent_class)->dispose (object); } static void input_capture_init (InputCapture *input_capture) { } static void input_capture_class_init (InputCaptureClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); object_class->dispose = input_capture_dispose; quark_request_session = g_quark_from_static_string ("-xdp-request-capture-input-session"); } static InputCapture * input_capture_new (XdpContext *context, XdpDbusImplInputCapture *impl) { InputCapture *input_capture; input_capture = g_object_new (input_capture_get_type (), NULL); input_capture->context = context; input_capture->impl = g_object_ref (impl); g_dbus_proxy_set_default_timeout (G_DBUS_PROXY (input_capture->impl), G_MAXINT); input_capture->impl_version = MAX (xdp_dbus_impl_input_capture_get_version (impl), 1); xdp_dbus_input_capture_set_version (XDP_DBUS_INPUT_CAPTURE (input_capture), MIN (input_capture->impl_version, 2)); g_object_bind_property (G_OBJECT (input_capture->impl), "supported-capabilities", G_OBJECT (input_capture), "supported-capabilities", G_BINDING_SYNC_CREATE); g_signal_connect_object (input_capture->impl, "disabled", G_CALLBACK (on_disabled_cb), input_capture, G_CONNECT_DEFAULT); g_signal_connect_object (input_capture->impl, "activated", G_CALLBACK (on_activated_cb), input_capture, G_CONNECT_DEFAULT); g_signal_connect_object (input_capture->impl, "deactivated", G_CALLBACK (on_deactivated_cb), input_capture, G_CONNECT_DEFAULT); g_signal_connect_object (input_capture->impl, "zones-changed", G_CALLBACK (on_zones_changed_cb), input_capture, G_CONNECT_DEFAULT); return input_capture; } void init_input_capture (XdpContext *context) { g_autoptr(InputCapture) input_capture = NULL; GDBusConnection *connection = xdp_context_get_connection (context); XdpPortalConfig *config = xdp_context_get_config (context); XdpImplConfig *impl_config; g_autoptr(XdpDbusImplInputCapture) impl = NULL; g_autoptr(GError) error = NULL; impl_config = xdp_portal_config_find (config, INPUT_CAPTURE_DBUS_IMPL_IFACE); if (impl_config == NULL) return; impl = xdp_dbus_impl_input_capture_proxy_new_sync (connection, G_DBUS_PROXY_FLAGS_NONE, impl_config->dbus_name, DESKTOP_DBUS_PATH, NULL, &error); if (impl == NULL) { g_warning ("Failed to create input capture proxy: %s", error->message); return; } input_capture = input_capture_new (context, impl); xdp_context_take_and_export_portal (context, G_DBUS_INTERFACE_SKELETON (g_steal_pointer (&input_capture)), XDP_CONTEXT_EXPORT_FLAGS_NONE); }