Merge lp:~3v1n0/unity-settings-daemon/automount-monitor-lockscreen into lp:unity-settings-daemon

[Marco Trevisan (Treviño)]

AutoMount: also try to connect to Unity Session and delay automounts when locked

Unity has a different concept from GNOME when it comes to the Screensaver: this one
is only responsible of blanking the screen, not to lock the session.
So, when unity is running we need to avoid to automount any volume when Unity is Locked
or when the Screensaver is Active (in some scenarios unity might still use the GNOME screensaver)

We just monitor com.canonical.Unity.Session.{Locked,Unlocked}() and allow automounts only when screensaver and lockscreen aren't running.

[Sebastien Bacher (seb128)]

Code seems fine to me, Marc did you want to review/test that one?

review: Approve

[Sebastien Bacher (seb128)]

tiny nitpick, but it would be nicer if the g_debug() statements in unity_session_signal_callback() would include the signal name (e.g "Unity.Session (Un)Locked")...

[Marco Trevisan (Treviño) (3v1n0)]

Ok, done.

[Sebastien Bacher (seb128)]

thanks ;-)

review: Approve

[Sebastien Bacher (seb128)]

bah, it fails to build, can you fix the "t" you added at the start of line 1?

review: Needs Fixing

[lp:~3v1n0/unity-settings-daemon/automount-monitor-lockscreen]

4085. By Marco Trevisan (Treviño) on 2015-06-30

AutomountManager: update unity lockscreen debuging strings to be more clear

=== modified file 'plugins/automount/gsd-automount-manager.c'
--- plugins/automount/gsd-automount-manager.c	2013-11-13 01:59:14 +0000
+++ plugins/automount/gsd-automount-manager.c	2015-06-30 15:16:07 +0000
@@ -45,8 +45,11 @@
         GDBusProxy *session;
         gboolean session_is_active;
         gboolean screensaver_active;
+        gboolean lockscreen_active;
         guint ss_watch_id;
+        guint us_watch_id;
         GDBusProxy *ss_proxy;
+        GDBusProxy *us_proxy;
 
         GList *volume_queue;
 };
@@ -178,7 +181,7 @@
         GList *l;
         GVolume *volume;
 
-        if (manager->priv->screensaver_active)
+        if (manager->priv->screensaver_active || manager->priv->lockscreen_active)
                 return;
 
         l = manager->priv->volume_queue;
@@ -198,13 +201,23 @@
 }
 
 static void
+clear_volume_queue (GsdAutomountManager *manager)
+{
+        if (!manager->priv->volume_queue)
+                return;
+
+        g_list_free_full (manager->priv->volume_queue, g_object_unref);
+        manager->priv->volume_queue = NULL;
+}
+
+static void
 check_screen_lock_and_mount (GsdAutomountManager *manager,
                              GVolume *volume)
 {
         if (!manager->priv->session_is_active)
                 return;
 
-        if (manager->priv->screensaver_active) {
+        if (manager->priv->screensaver_active || manager->priv->lockscreen_active) {
                 /* queue the volume, to mount it after the screensaver state changed */
                 g_debug ("Queuing volume %p", volume);
                 manager->priv->volume_queue = g_list_prepend (manager->priv->volume_queue,
@@ -470,12 +483,11 @@
         manager->priv->screensaver_active = FALSE;
         g_clear_object (&manager->priv->ss_proxy);
 
-        /* in this case force a clear of the volume queue, without
-         * mounting them.
-         */
-        if (manager->priv->volume_queue != NULL) {
-                g_list_free_full (manager->priv->volume_queue, g_object_unref);
-                manager->priv->volume_queue = NULL;
+        if (!manager->priv->ss_proxy && !manager->priv->us_proxy) {
+                /* in this case force a clear of the volume queue, without
+                 * mounting them.
+                 */
+                clear_volume_queue (manager);
         }
 }
 
@@ -494,11 +506,158 @@
                                   NULL);
 }
 
+#define UNITY_NAME "com.canonical.Unity"
+#define UNITY_SESSION_PATH "/com/canonical/Unity/Session"
+#define UNITY_SESSION_INTERFACE "com.canonical.Unity.Session"
+
+static void
+unity_session_signal_callback (GDBusProxy *proxy,
+                               const gchar *sender_name,
+                               const gchar *signal_name,
+                               GVariant *parameters,
+                               gpointer user_data)
+{
+        GsdAutomountManager *manager = user_data;
+
+        if (g_strcmp0 (signal_name, "Locked") == 0) {
+                manager->priv->lockscreen_active = TRUE;
+                check_volume_queue (manager);
+                g_debug ("Unity.Session Locked");
+        } else if (g_strcmp0 (signal_name, "Unlocked") == 0) {
+                manager->priv->lockscreen_active = FALSE;
+                check_volume_queue (manager);
+                g_debug ("Unity.Session Unlocked");
+        }
+}
+
+static void
+unity_session_is_locked_cb (GObject *source,
+                            GAsyncResult *res,
+                            gpointer user_data)
+{
+        GsdAutomountManager *manager = user_data;
+        GDBusProxy *proxy = manager->priv->us_proxy;
+        GVariant *result;
+        GError *error = NULL;
+
+        result = g_dbus_proxy_call_finish (proxy,
+                                           res,
+                                           &error);
+
+        if (error != NULL) {
+                g_warning ("Can't call IsLocked() on the Unity.Session object: %s",
+                           error->message);
+                g_error_free (error);
+
+                return;
+        }
+
+        g_variant_get (result, "(b)", &manager->priv->lockscreen_active);
+        g_variant_unref (result);
+
+        g_debug ("Unity Session IsLocked() returned %d", manager->priv->lockscreen_active);
+}
+
+static void
+unity_session_proxy_ready_cb (GObject *source,
+                              GAsyncResult *res,
+                              gpointer user_data)
+{
+        GsdAutomountManager *manager = user_data;
+        GError *error = NULL;
+        GDBusProxy *us_proxy;
+
+        us_proxy = g_dbus_proxy_new_finish (res, &error);
+
+        if (error != NULL) {
+                g_warning ("Can't get proxy for the Unity Session object: %s",
+                           error->message);
+                g_error_free (error);
+
+                return;
+        }
+
+        g_debug ("Unity Session proxy ready");
+
+        manager->priv->us_proxy = us_proxy;
+
+        g_signal_connect (us_proxy, "g-signal",
+                          G_CALLBACK (unity_session_signal_callback), manager);
+
+        g_dbus_proxy_call (us_proxy,
+                           "IsLocked",
+                           NULL,
+                           G_DBUS_CALL_FLAGS_NO_AUTO_START,
+                           -1,
+                           NULL,
+                           unity_session_is_locked_cb,
+                           manager);
+}
+
+static void
+unity_appeared_callback (GDBusConnection *connection,
+                         const gchar *name,
+                         const gchar *name_owner,
+                         gpointer user_data)
+{
+        GsdAutomountManager *manager = user_data;
+
+        g_debug ("Unity name appeared");
+
+        manager->priv->lockscreen_active = FALSE;
+
+        g_dbus_proxy_new (connection,
+                          G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
+                          NULL,
+                          name,
+                          UNITY_SESSION_PATH,
+                          UNITY_SESSION_INTERFACE,
+                          NULL,
+                          unity_session_proxy_ready_cb,
+                          manager);
+}
+
+static void
+unity_vanished_callback (GDBusConnection *connection,
+                               const gchar *name,
+                               gpointer user_data)
+{
+        GsdAutomountManager *manager = user_data;
+
+        g_debug ("Unity name vanished");
+
+        manager->priv->lockscreen_active = FALSE;
+        g_clear_object (&manager->priv->us_proxy);
+
+        if (!manager->priv->ss_proxy && !manager->priv->us_proxy) {
+                /* in this case force a clear of the volume queue, without
+                 * mounting them.
+                 */
+                clear_volume_queue (manager);
+        }
+}
+
+static void
+do_initialize_lockscreen (GsdAutomountManager *manager)
+{
+        GsdAutomountManagerPrivate *p = manager->priv;
+
+        p->us_watch_id =
+                g_bus_watch_name (G_BUS_TYPE_SESSION,
+                                  UNITY_NAME,
+                                  G_BUS_NAME_WATCHER_FLAGS_NONE,
+                                  unity_appeared_callback,
+                                  unity_vanished_callback,
+                                  manager,
+                                  NULL);
+}
+
 static void
 setup_automounter (GsdAutomountManager *manager)
 {
         do_initialize_session (manager);
         do_initialize_screensaver (manager);
+        do_initialize_lockscreen (manager);
 
 	manager->priv->volume_monitor = g_volume_monitor_get ();
 	g_signal_connect_object (manager->priv->volume_monitor, "mount-added",
@@ -540,8 +699,10 @@
         g_clear_object (&p->volume_monitor);
         g_clear_object (&p->settings);
         g_clear_object (&p->ss_proxy);
+        g_clear_object (&p->us_proxy);
 
         g_bus_unwatch_name (p->ss_watch_id);
+        g_bus_unwatch_name (p->us_watch_id);
 
         if (p->volume_queue != NULL) {
                 g_list_free_full (p->volume_queue, g_object_unref);