sungmg/mutter-performance-source
1
0
Fork 0
Code Activity

backends: Introduce MetaIdleManager

Browse source 
This object takes over the functionality of meta-idle-monitor-dbus.c,
meta-idle-monitor.c and meta-backend.c, all related to higher level
management of idle watches etc.

The idle D-Bus API is changed to be initialized by the backend instead
of MetaDisplay, as it's more of a backend functionality than what
MetaDisplay usually deals with.

It also takes over the work of implementing "core" idle monitors. The
singleton API is replaced with thin wrapper functions on the backend.

Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1859>
This commit is contained in:
Jonas Ådahl 2021-04-19 15:22:57 +02:00 committed by Marge Bot
parent 389432de46
commit 18d670e69f
14 changed files with 274 additions and 200 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
src/backends/meta-backend-private.h
View file

@ -129,9 +129,8 @@ ClutterSeat * meta_backend_get_default_seat (MetaBackend *bakcend);
MetaIdleMonitor * meta_backend_get_idle_monitor (MetaBackend *backend,
ClutterInputDevice *device);
void meta_backend_foreach_device_monitor (MetaBackend *backend,
GFunc func,
gpointer user_data);
MetaIdleManager * meta_backend_get_idle_manager (MetaBackend *backend);
META_EXPORT_TEST
MetaMonitorManager * meta_backend_get_monitor_manager (MetaBackend *backend);

2
src/backends/meta-backend-types.h
View file

@ -62,6 +62,8 @@ typedef struct _MetaWaylandCompositor MetaWaylandCompositor;
typedef struct _MetaVirtualMonitor MetaVirtualMonitor;
typedef struct _MetaVirtualMonitorInfo MetaVirtualMonitorInfo;
typedef struct _MetaIdleManager MetaIdleManager;
#ifdef HAVE_REMOTE_DESKTOP
typedef struct _MetaRemoteDesktop MetaRemoteDesktop;
#endif

132
src/backends/meta-backend.c
View file

@ -55,6 +55,7 @@
#include "backends/meta-cursor-renderer.h"
#include "backends/meta-cursor-tracker-private.h"
#include "backends/meta-idle-manager.h"
#include "backends/meta-idle-monitor-private.h"
#include "backends/meta-input-mapper-private.h"
#include "backends/meta-input-settings-private.h"
@ -125,6 +126,7 @@ struct _MetaBackendPrivate
MetaOrientationManager *orientation_manager;
MetaCursorTracker *cursor_tracker;
MetaInputMapper *input_mapper;
MetaIdleManager *idle_manager;
MetaRenderer *renderer;
#ifdef HAVE_EGL
MetaEgl *egl;
@ -160,8 +162,6 @@ struct _MetaBackendPrivate
guint device_update_idle_id;
GHashTable *device_monitors;
ClutterInputDevice *current_device;
MetaPointerConstraint *client_pointer_constraint;
@ -233,8 +233,6 @@ meta_backend_dispose (GObject *object)
g_clear_handle_id (&priv->device_update_idle_id, g_source_remove);
g_clear_pointer (&priv->device_monitors, g_hash_table_destroy);
g_clear_object (&priv->settings);
#ifdef HAVE_PROFILER
@ -244,6 +242,7 @@ meta_backend_dispose (GObject *object)
g_clear_pointer (&priv->default_seat, clutter_seat_destroy);
g_clear_pointer (&priv->stage, clutter_actor_destroy);
g_clear_pointer (&priv->clutter_backend, clutter_backend_destroy);
g_clear_pointer (&priv->idle_manager, meta_idle_manager_free);
g_clear_object (&priv->renderer);
g_clear_list (&priv->gpus, g_object_unref);
@ -361,63 +360,6 @@ meta_backend_monitors_changed (MetaBackend *backend)
update_cursors (backend);
}
void
meta_backend_foreach_device_monitor (MetaBackend *backend,
GFunc func,
gpointer user_data)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
GHashTableIter iter;
gpointer value;
g_hash_table_iter_init (&iter, priv->device_monitors);
while (g_hash_table_iter_next (&iter, NULL, &value))
{
MetaIdleMonitor *device_monitor = META_IDLE_MONITOR (value);
func (device_monitor, user_data);
}
}
static MetaIdleMonitor *
meta_backend_create_idle_monitor (MetaBackend *backend,
ClutterInputDevice *device)
{
return g_object_new (META_TYPE_IDLE_MONITOR,
"device", device,
NULL);
}
static void
create_device_monitor (MetaBackend *backend,
ClutterInputDevice *device)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
MetaIdleMonitor *idle_monitor;
if (g_hash_table_contains (priv->device_monitors, device))
return;
idle_monitor = meta_backend_create_idle_monitor (backend, device);
g_hash_table_insert (priv->device_monitors, device, idle_monitor);
}
static void
destroy_device_monitor (MetaBackend *backend,
ClutterInputDevice *device)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
g_hash_table_remove (priv->device_monitors, device);
}
static void
meta_backend_monitor_device (MetaBackend *backend,
ClutterInputDevice *device)
{
create_device_monitor (backend, device);
}
static inline gboolean
check_has_pointing_device (ClutterSeat *seat)
{
@ -454,8 +396,6 @@ on_device_added (ClutterSeat *seat,
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
ClutterInputDeviceType device_type;
create_device_monitor (backend, device);
if (clutter_input_device_get_device_mode (device) ==
CLUTTER_INPUT_MODE_LOGICAL)
return;
@ -485,8 +425,6 @@ on_device_removed (ClutterSeat *seat,
MetaBackend *backend = META_BACKEND (user_data);
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
destroy_device_monitor (backend, device);
if (clutter_input_device_get_device_mode (device) ==
CLUTTER_INPUT_MODE_LOGICAL)
return;
@ -526,26 +464,6 @@ on_device_removed (ClutterSeat *seat,
meta_backend_update_last_device (backend, NULL);
}
static void
create_device_monitors (MetaBackend *backend,
ClutterSeat *seat)
{
GList *l, *devices;
create_device_monitor (backend, clutter_seat_get_pointer (seat));
create_device_monitor (backend, clutter_seat_get_keyboard (seat));
devices = clutter_seat_list_devices (seat);
for (l = devices; l; l = l->next)
{
ClutterInputDevice *device = l->data;
meta_backend_monitor_device (backend, device);
}
g_list_free (devices);
}
static void
input_mapper_device_mapped_cb (MetaInputMapper *mapper,
ClutterInputDevice *device,
@ -617,10 +535,7 @@ meta_backend_real_post_init (MetaBackend *backend)
meta_backend_sync_screen_size (backend);
priv->device_monitors =
g_hash_table_new_full (NULL, NULL, NULL, (GDestroyNotify) g_object_unref);
create_device_monitors (backend, seat);
priv->idle_manager = meta_idle_manager_new (backend);
g_signal_connect_object (seat, "device-added",
G_CALLBACK (on_device_added), backend, 0);
@ -740,7 +655,7 @@ upower_properties_changed (GDBusProxy *proxy,
if (lid_is_closed)
return;
meta_idle_monitor_reset_idletime (meta_idle_monitor_get_core ());
meta_idle_manager_reset_idle_time (priv->idle_manager);
}
static void
@ -935,12 +850,15 @@ prepare_for_sleep_cb (GDBusConnection *connection,
GVariant *parameters,
gpointer user_data)
{
MetaBackend *backend = user_data;
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
gboolean suspending;
g_variant_get (parameters, "(b)", &suspending);
if (suspending)
return;
meta_idle_monitor_reset_idletime (meta_idle_monitor_get_core ());
meta_idle_manager_reset_idle_time (priv->idle_manager);
}
static void
@ -948,6 +866,7 @@ system_bus_gotten_cb (GObject *object,
GAsyncResult *res,
gpointer user_data)
{
MetaBackend *backend = user_data;
MetaBackendPrivate *priv;
GDBusConnection *bus;
@ -955,7 +874,7 @@ system_bus_gotten_cb (GObject *object,
if (!bus)
return;
priv = meta_backend_get_instance_private (user_data);
priv = meta_backend_get_instance_private (backend);
priv->system_bus = bus;
priv->sleep_signal_id =
g_dbus_connection_signal_subscribe (priv->system_bus,
@ -966,7 +885,7 @@ system_bus_gotten_cb (GObject *object,
NULL,
G_DBUS_SIGNAL_FLAGS_NONE,
prepare_for_sleep_cb,
NULL,
backend,
NULL);
}
@ -1170,7 +1089,32 @@ meta_backend_get_idle_monitor (MetaBackend *backend,
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
return g_hash_table_lookup (priv->device_monitors, device);
return meta_idle_manager_get_monitor (priv->idle_manager, device);
}
/**
* meta_backend_get_core_idle_monitor:
*
* Returns: (transfer none): the #MetaIdleMonitor that tracks server-global
* idle time for all devices.
*/
MetaIdleMonitor *
meta_backend_get_core_idle_monitor (MetaBackend *backend)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
return meta_idle_manager_get_core_monitor (priv->idle_manager);
}
/**
* meta_backend_get_idle_manager: (skip)
*/
MetaIdleManager *
meta_backend_get_idle_manager (MetaBackend *backend)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
return priv->idle_manager;
}
/**

172
src/backends/meta-idle-monitor-dbus.c → src/backends/meta-idle-manager.c
View file

@ -1,7 +1,7 @@
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/*
* Copyright 2013 Red Hat, Inc.
* Copyright 2013-2021 Red Hat, Inc.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
@ -22,7 +22,7 @@
#include "config.h"
#include "backends/meta-idle-monitor-dbus.h"
#include "backends/meta-idle-manager.h"
#include "backends/meta-idle-monitor-private.h"
#include "clutter/clutter.h"
@ -32,6 +32,14 @@
#include "meta-dbus-idle-monitor.h"
typedef struct _MetaIdleManager
{
MetaBackend *backend;
guint dbus_name_id;
GHashTable *device_monitors;
} MetaIdleManager;
static gboolean
handle_get_idletime (MetaDBusIdleMonitor *skeleton,
GDBusMethodInvocation *invocation,
@ -59,7 +67,7 @@ handle_reset_idletime (MetaDBusIdleMonitor *skeleton,
return TRUE;
}
meta_idle_monitor_reset_idletime (meta_idle_monitor_get_core ());
meta_idle_manager_reset_idle_time (meta_idle_monitor_get_manager (monitor));
meta_dbus_idle_monitor_complete_reset_idletime (skeleton, invocation);
return TRUE;
@ -189,16 +197,16 @@ create_monitor_skeleton (GDBusObjectManagerServer *manager,
MetaDBusObjectSkeleton *object;
skeleton = meta_dbus_idle_monitor_skeleton_new ();
g_signal_connect_object (skeleton, "handle-add-idle-watch",
G_CALLBACK (handle_add_idle_watch), monitor, 0);
g_signal_connect_object (skeleton, "handle-add-user-active-watch",
G_CALLBACK (handle_add_user_active_watch), monitor, 0);
g_signal_connect_object (skeleton, "handle-remove-watch",
G_CALLBACK (handle_remove_watch), monitor, 0);
g_signal_connect_object (skeleton, "handle-reset-idletime",
G_CALLBACK (handle_reset_idletime), monitor, 0);
g_signal_connect_object (skeleton, "handle-get-idletime",
G_CALLBACK (handle_get_idletime), monitor, 0);
g_signal_connect (skeleton, "handle-add-idle-watch",
G_CALLBACK (handle_add_idle_watch), monitor);
g_signal_connect (skeleton, "handle-add-user-active-watch",
G_CALLBACK (handle_add_user_active_watch), monitor);
g_signal_connect (skeleton, "handle-remove-watch",
G_CALLBACK (handle_remove_watch), monitor);
g_signal_connect (skeleton, "handle-reset-idletime",
G_CALLBACK (handle_reset_idletime), monitor);
g_signal_connect (skeleton, "handle-get-idletime",
G_CALLBACK (handle_get_idletime), monitor);
object = meta_dbus_object_skeleton_new (path);
meta_dbus_object_skeleton_set_idle_monitor (object, skeleton);
@ -214,20 +222,21 @@ on_bus_acquired (GDBusConnection *connection,
const char *name,
gpointer user_data)
{
GDBusObjectManagerServer *manager;
MetaIdleManager *manager = user_data;
GDBusObjectManagerServer *object_manager;
MetaIdleMonitor *monitor;
char *path;
manager = g_dbus_object_manager_server_new ("/org/gnome/Mutter/IdleMonitor");
object_manager = g_dbus_object_manager_server_new ("/org/gnome/Mutter/IdleMonitor");
/* We never clear the core monitor, as that's supposed to cumulate idle times from
all devices */
monitor = meta_idle_monitor_get_core ();
monitor = meta_idle_manager_get_core_monitor (manager);
path = g_strdup ("/org/gnome/Mutter/IdleMonitor/Core");
create_monitor_skeleton (manager, monitor, path);
create_monitor_skeleton (object_manager, monitor, path);
g_free (path);
g_dbus_object_manager_server_set_connection (manager, connection);
g_dbus_object_manager_server_set_connection (object_manager, connection);
}
static void
@ -246,21 +255,122 @@ on_name_lost (GDBusConnection *connection,
meta_verbose ("Lost or failed to acquire name %s", name);
}
void
meta_idle_monitor_init_dbus (void)
MetaIdleMonitor *
meta_idle_manager_get_monitor (MetaIdleManager *idle_manager,
ClutterInputDevice *device)
{
static int dbus_name_id;
return g_hash_table_lookup (idle_manager->device_monitors, device);
}
if (dbus_name_id > 0)
MetaIdleMonitor *
meta_idle_manager_get_core_monitor (MetaIdleManager *idle_manager)
{
MetaBackend *backend = meta_get_backend ();
ClutterBackend *clutter_backend = meta_backend_get_clutter_backend (backend);
ClutterSeat *seat = clutter_backend_get_default_seat (clutter_backend);
return meta_backend_get_idle_monitor (backend,
clutter_seat_get_pointer (seat));
}
void
meta_idle_manager_reset_idle_time (MetaIdleManager *idle_manager)
{
MetaIdleMonitor *core_monitor;
core_monitor = meta_idle_manager_get_core_monitor (idle_manager);
meta_idle_monitor_reset_idletime (core_monitor);
}
static void
create_device_monitor (MetaIdleManager *idle_manager,
ClutterInputDevice *device)
{
MetaIdleMonitor *idle_monitor;
if (g_hash_table_contains (idle_manager->device_monitors, device))
return;
dbus_name_id = g_bus_own_name (G_BUS_TYPE_SESSION,
"org.gnome.Mutter.IdleMonitor",
G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT |
(meta_get_replace_current_wm () ?
G_BUS_NAME_OWNER_FLAGS_REPLACE : 0),
on_bus_acquired,
on_name_acquired,
on_name_lost,
NULL, NULL);
idle_monitor = meta_idle_monitor_new (idle_manager, device);
g_hash_table_insert (idle_manager->device_monitors, device, idle_monitor);
}
static void
on_device_added (ClutterSeat *seat,
ClutterInputDevice *device,
gpointer user_data)
{
MetaIdleManager *idle_manager = user_data;
create_device_monitor (idle_manager, device);
}
static void
on_device_removed (ClutterSeat *seat,
ClutterInputDevice *device,
gpointer user_data)
{
MetaIdleManager *idle_manager = user_data;
g_hash_table_remove (idle_manager->device_monitors, device);
}
static void
create_device_monitors (MetaIdleManager *idle_manager,
ClutterSeat *seat)
{
GList *l, *devices;
create_device_monitor (idle_manager, clutter_seat_get_pointer (seat));
create_device_monitor (idle_manager, clutter_seat_get_keyboard (seat));
devices = clutter_seat_list_devices (seat);
for (l = devices; l; l = l->next)
{
ClutterInputDevice *device = l->data;
create_device_monitor (idle_manager, device);
}
g_list_free (devices);
}
MetaIdleManager *
meta_idle_manager_new (MetaBackend *backend)
{
ClutterSeat *seat = meta_backend_get_default_seat (backend);
MetaIdleManager *idle_manager;
idle_manager = g_new0 (MetaIdleManager, 1);
idle_manager->backend = backend;
idle_manager->dbus_name_id =
g_bus_own_name (G_BUS_TYPE_SESSION,
"org.gnome.Mutter.IdleMonitor",
G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT |
(meta_get_replace_current_wm () ?
G_BUS_NAME_OWNER_FLAGS_REPLACE : 0),
on_bus_acquired,
on_name_acquired,
on_name_lost,
idle_manager,
NULL);
idle_manager->device_monitors =
g_hash_table_new_full (NULL, NULL, NULL, (GDestroyNotify) g_object_unref);
g_signal_connect (seat, "device-added",
G_CALLBACK (on_device_added), idle_manager);
g_signal_connect_after (seat, "device-removed",
G_CALLBACK (on_device_removed), idle_manager);
create_device_monitors (idle_manager, seat);
return idle_manager;
}
void
meta_idle_manager_free (MetaIdleManager *idle_manager)
{
g_clear_pointer (&idle_manager->device_monitors, g_hash_table_destroy);
g_bus_unown_name (idle_manager->dbus_name_id);
g_free (idle_manager);
}

39
src/backends/meta-idle-manager.h Normal file
View file

@ -0,0 +1,39 @@
/*
* Copyright 2021 Red Hat, Inc.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program 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
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <http://www.gnu.org/licenses/>.
*
*/
#ifndef META_IDLE_MANAGER_H
#define META_IDLE_MANAGER_H
#include "backends/meta-backend-types.h"
#include "clutter/clutter.h"
typedef struct _MetaIdleMonitor MetaIdleMonitor;
typedef struct _MetaIdleManager MetaIdleManager;
MetaIdleMonitor * meta_idle_manager_get_monitor (MetaIdleManager *idle_manager,
ClutterInputDevice *device);
MetaIdleMonitor * meta_idle_manager_get_core_monitor (MetaIdleManager *idle_manager);
void meta_idle_manager_reset_idle_time (MetaIdleManager *idle_manager);
MetaIdleManager * meta_idle_manager_new (MetaBackend *backend);
void meta_idle_manager_free (MetaIdleManager *idle_manager);
#endif /* META_IDLE_MANAGER_H */

28
src/backends/meta-idle-monitor-dbus.h
View file

@ -1,28 +0,0 @@
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/*
* Copyright 2013 Red Hat, Inc.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program 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
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <http://www.gnu.org/licenses/>.
*
* Adapted from gnome-session/gnome-session/gs-idle-monitor.c and
* from gnome-desktop/libgnome-desktop/gnome-idle-monitor.c
*/
#ifndef META_IDLE_MONITOR_DBUS_H
#define META_IDLE_MONITOR_DBUS_H
void meta_idle_monitor_init_dbus (void);
#endif

16
src/backends/meta-idle-monitor-private.h
View file

@ -38,17 +38,6 @@ typedef struct
GSource *timeout_source;
} MetaIdleMonitorWatch;
struct _MetaIdleMonitor
{
GObject parent_instance;
GDBusProxy *session_proxy;
gboolean inhibited;
GHashTable *watches;
ClutterInputDevice *device;
guint64 last_event_time;
};
struct _MetaIdleMonitorClass
{
GObjectClass parent_class;
@ -56,4 +45,9 @@ struct _MetaIdleMonitorClass
void meta_idle_monitor_reset_idletime (MetaIdleMonitor *monitor);
MetaIdleManager * meta_idle_monitor_get_manager (MetaIdleMonitor *monitor);
MetaIdleMonitor * meta_idle_monitor_new (MetaIdleManager *idle_manager,
ClutterInputDevice *device);
#endif /* META_IDLE_MONITOR_PRIVATE_H */

49
src/backends/meta-idle-monitor.c
View file

@ -35,7 +35,6 @@
#include "backends/gsm-inhibitor-flag.h"
#include "backends/meta-backend-private.h"
#include "backends/meta-idle-monitor-private.h"
#include "backends/meta-idle-monitor-dbus.h"
#include "clutter/clutter.h"
#include "meta/main.h"
#include "meta/meta-idle-monitor.h"
@ -52,6 +51,18 @@ enum
static GParamSpec *obj_props[PROP_LAST];
struct _MetaIdleMonitor
{
GObject parent;
MetaIdleManager *idle_manager;
GDBusProxy *session_proxy;
gboolean inhibited;
GHashTable *watches;
ClutterInputDevice *device;
int64_t last_event_time;
};
G_DEFINE_TYPE (MetaIdleMonitor, meta_idle_monitor, G_TYPE_OBJECT)
static void
@ -266,22 +277,6 @@ meta_idle_monitor_init (MetaIdleMonitor *monitor)
}
}
/**
* meta_idle_monitor_get_core:
*
* Returns: (transfer none): the #MetaIdleMonitor that tracks the server-global
* idletime for all devices.
*/
MetaIdleMonitor *
meta_idle_monitor_get_core (void)
{
MetaBackend *backend = meta_get_backend ();
ClutterBackend *clutter_backend = meta_backend_get_clutter_backend (backend);
ClutterSeat *seat = clutter_backend_get_default_seat (clutter_backend);
return meta_backend_get_idle_monitor (backend, clutter_seat_get_pointer (seat));
}
static guint32
get_next_watch_serial (void)
{
@ -513,3 +508,23 @@ meta_idle_monitor_reset_idletime (MetaIdleMonitor *monitor)
g_list_free (watch_ids);
}
MetaIdleManager *
meta_idle_monitor_get_manager (MetaIdleMonitor *monitor)
{
return monitor->idle_manager;
}
MetaIdleMonitor *
meta_idle_monitor_new (MetaIdleManager *idle_manager,
ClutterInputDevice *device)
{
MetaIdleMonitor *monitor;
monitor = g_object_new (META_TYPE_IDLE_MONITOR,
"device", device,
NULL);
monitor->idle_manager = idle_manager;
return monitor;
}

8
src/backends/native/meta-backend-native.c
View file

@ -42,7 +42,7 @@
#include <stdlib.h>
#include "backends/meta-cursor-tracker-private.h"
#include "backends/meta-idle-monitor-private.h"
#include "backends/meta-idle-manager.h"
#include "backends/meta-keymap-utils.h"
#include "backends/meta-logical-monitor.h"
#include "backends/meta-monitor-manager-private.h"
@ -726,11 +726,11 @@ void meta_backend_native_resume (MetaBackendNative *native)
meta_backend_get_monitor_manager (backend);
MetaMonitorManagerNative *monitor_manager_native =
META_MONITOR_MANAGER_NATIVE (monitor_manager);
MetaIdleMonitor *idle_monitor;
ClutterBackend *clutter_backend = meta_backend_get_clutter_backend (backend);
MetaSeatNative *seat =
META_SEAT_NATIVE (clutter_backend_get_default_seat (clutter_backend));
MetaRenderer *renderer = meta_backend_get_renderer (backend);
MetaIdleManager *idle_manager;
MetaInputSettings *input_settings;
COGL_TRACE_BEGIN_SCOPED (MetaBackendNativeResume,
@ -746,8 +746,8 @@ void meta_backend_native_resume (MetaBackendNative *native)
clutter_actor_queue_redraw (CLUTTER_ACTOR (stage));
idle_monitor = meta_idle_monitor_get_core ();
meta_idle_monitor_reset_idletime (idle_monitor);
idle_manager = meta_backend_get_idle_manager (backend);
meta_idle_manager_reset_idle_time (idle_manager);
input_settings = meta_backend_get_input_settings (backend);
meta_input_settings_maybe_restore_numlock_state (input_settings);

3
src/core/display.c
View file

@ -43,7 +43,6 @@
#include "backends/meta-backend-private.h"
#include "backends/meta-cursor-sprite-xcursor.h"
#include "backends/meta-cursor-tracker-private.h"
#include "backends/meta-idle-monitor-dbus.h"
#include "backends/meta-input-device-private.h"
#include "backends/meta-input-mapper-private.h"
#include "backends/meta-stage-private.h"
@ -960,8 +959,6 @@ meta_display_open (GError **error)
meta_display_unset_input_focus (display, timestamp);
}
meta_idle_monitor_init_dbus ();
display->sound_player = g_object_new (META_TYPE_SOUND_PLAYER, NULL);
/* Done opening new display */

9
src/core/events.c
View file

@ -25,7 +25,7 @@
#include "core/events.h"
#include "backends/meta-cursor-tracker-private.h"
#include "backends/meta-idle-monitor-private.h"
#include "backends/meta-idle-manager.h"
#include "backends/x11/meta-backend-x11.h"
#include "backends/x11/meta-input-device-x11.h"
#include "compositor/meta-window-actor-private.h"
@ -102,7 +102,8 @@ get_window_for_event (MetaDisplay *display,
static void
handle_idletime_for_event (const ClutterEvent *event)
{
MetaIdleMonitor *core_monitor;
MetaBackend *backend = meta_get_backend ();
MetaIdleManager *idle_manager;
if (clutter_event_get_device (event) == NULL)
return;
@ -112,8 +113,8 @@ handle_idletime_for_event (const ClutterEvent *event)
event->type == CLUTTER_LEAVE)
return;
core_monitor = meta_idle_monitor_get_core ();
meta_idle_monitor_reset_idletime (core_monitor);
idle_manager = meta_backend_get_idle_manager (backend);
meta_idle_manager_reset_idle_time (idle_manager);
}
static gboolean

4
src/meson.build
View file

@ -188,8 +188,8 @@ mutter_sources = [
'backends/meta-gpu.c',
'backends/meta-gpu.h',
'backends/meta-idle-monitor.c',
'backends/meta-idle-monitor-dbus.c',
'backends/meta-idle-monitor-dbus.h',
'backends/meta-idle-manager.c',
'backends/meta-idle-manager.h',
'backends/meta-idle-monitor-private.h',
'backends/meta-input-device.c',
'backends/meta-input-mapper.c',

4
src/meta/meta-backend.h
View file

@ -29,6 +29,7 @@
#include "clutter/clutter.h"
#include "meta/meta-dnd.h"
#include "meta/meta-idle-monitor.h"
#include "meta/meta-remote-access-controller.h"
#define META_TYPE_BACKEND (meta_backend_get_type ())
@ -61,6 +62,9 @@ MetaDnd *meta_backend_get_dnd (MetaBackend *backend);
META_EXPORT
MetaSettings *meta_backend_get_settings (MetaBackend *backend);
META_EXPORT
MetaIdleMonitor * meta_backend_get_core_idle_monitor (MetaBackend *backend);
META_EXPORT
MetaRemoteAccessController * meta_backend_get_remote_access_controller (MetaBackend *backend);

3
src/meta/meta-idle-monitor.h
View file

@ -40,9 +40,6 @@ typedef void (*MetaIdleMonitorWatchFunc) (MetaIdleMonitor *monitor,
guint watch_id,
gpointer user_data);
META_EXPORT
MetaIdleMonitor *meta_idle_monitor_get_core (void);
META_EXPORT
guint meta_idle_monitor_add_idle_watch (MetaIdleMonitor *monitor,
guint64 interval_msec,