/*
* 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);
}