Merge lp:~cameronnemo/switchboard-plug-security-privacy/light-locker into lp:~elementary-apps/switchboard-plug-security-privacy/trunk

[Cameron Norman]

This is the branch to transition the security and privacy settings plug to light locker.

Three things here:

1) We need to import this light-locker branch for the lock-on-suspend setting to work: https://github.com/bluesabre/light-locker

2) The solution to the inactivity timeout is not exactly pretty. Unfortunately the main alternatives involve significant work in upstream software / big patches that software. That said, it works pretty reliably and I do not think it is significantly error prone.

3) The phrasing for "Lock screen after: Never" is a little awk. Also, I am not sure if the text is made longer that the nice alignment with the median at the center will be preserved. I am not too experienced with all those Gtk widgets, sorry.

I am hoping for some suggestions on that last one.

Anyway, basic synopsis of what it does is it uses Light Locker's gsettings schema vs. the gnome-screensaver one for lock on suspend. It also has a custom gsettings schema and a small script for inactivity timeouts through xautolock. Since we can not change the timeout on the fly, the plug kills the running xautolock process and starts a new one.

Unfortunately I will be on a scuba trip until wednesday night, so if there is some small issue feel free to work on it. You are even welcome to assign the bug to yourself and grab the bounty; I would much rather prefer coming closer to an rc than the $50.

Thanks for reviewing, Cameron Norman.

[lp:~cameronnemo/switchboard-plug-security-privacy/light-locker]

99. By Cameron Norman on 2014-11-23

Avoid having two xautolock processes running

100. By Cameron Norman on 2014-11-29

Even more dependencies! (for gsettings command)

[Cameron Norman (cameronnemo)]

carl wrote:

>So if I follow you, you recommend to use light-locker. Which is also a solution for the "turn off the screen after x" feature that doesn't work at the moment, if this has to be believed: https://bugs.launchpad.net/switchboard-plug-power/+bug/1373602/comments/4

Well we have already settled on light-locker, but that component does not actually turn off the screen after a timeout. The xautolock process is locking the screen after a timeout specified in the dconf key org.pantheon.xautolock timeout. As a side effect, the screen is being shut off at that same timeout.

[Simon Steinbeiß (ochosi)]

There is no need for xautolock, because light-locker already listens to X11's blank-time signal (or if that isn't set, it listens to DPMS suspend or whatever). You can easily test that by enabling timed locking and setting your timeout to 1 minute in the terminal: "xset s 60" (by default it's 600 seconds, so 10 minutes).

If you're handling setting the xserver's blank times somewhere, this is the time it takes until your session will be auto-locked.

[Cameron Norman (cameronnemo)]

Yeah I saw your message about xset on Slack a few days ago, have not been able to update the branch yet.

So instead of calling xautolock in xautolock-elementary, we should just call `xset s $timeout`, yes?

That is nicer on the code side for sure, but I am getting an ugly flash where the screen turns on and off when light-locker does the VT switch. Do you know of any way to avoid that?

If not, it is not too noticeable, and the user will usually not notice it because they are away from the computer when this occurs.

[lp:~cameronnemo/switchboard-plug-security-privacy/light-locker]

101. By Cameron Norman on 2014-12-13

Use xset instead of xautolock

102. By Cameron Norman on 2014-12-13

Fix debian install file for the changed names

103. By Cameron Norman on 2014-12-20

Fix when lock timeout is never

[Cody Garver (codygarver)]

Does not seem to work after a lock has already occurred. I set screen lock timeout for 1 minute, then unlocked and waited another minute and the second lock never happened.

[Cameron Norman (cameronnemo)]

What is the X inactivity timeout setting before and after the first lock? Use `xset q` and look under the Screen Saver section to identify it.

[lp:~cameronnemo/switchboard-plug-security-privacy/light-locker]

104. By Cameron Norman on 2014-12-27

xset usage: Use DPMS standby instead of screensaver

[Cameron Norman (cameronnemo)]

Alright so I am using a different, but supposedly equivalent, setting in this new revision and it seems to have fixed the issue.

[PerfectCarl (name-is-carl)]

Not that this is related to this branch per se but could you fix those minor issues:
  - remove the "--save-temps" in cmake/PrecompileVala.cmake to fix the warning:
       warning: --save-temps has no effect when -C or --ccode is set

[lp:~cameronnemo/switchboard-plug-security-privacy/light-locker]

105. By Cameron Norman on 2014-12-30

Make sure the autostart file is placed in the correct location

[PerfectCarl (name-is-carl)]

I've been testing the branch and it works well on my single monitor set up.

As cody mentioned there is still an issue with app that steals the focus (slinghost and plank).
When any of those app is active (slinghost is opened) the session doesn't lock.

At the moment, it isn't clear where the bug lies: the plug, light-locker...

[PerfectCarl (name-is-carl)]

Note: not that this is related to this branch but the default value for apps.light-locker.lock-after-screensaver should be 1 instead of 5.

Setting the value to 1 makes the locking feels more responsive and decrease the time during which the screen is totally black (and a little stressful to be honest) before being redirected to the greeter.

[lp:~cameronnemo/switchboard-plug-security-privacy/light-locker]

106. By Cody Garver on 2015-02-02

Start adapting to elementary-dpms-helper

107. By Cameron Norman on 2015-02-03

Adapt plug UI to use elementary-dpms-helper

108. By Cody Garver on 2015-02-03

dpms helper has moved

109. By Cameron Norman on 2015-02-03

Use seconds for the dpms value, not minutes

=== modified file 'debian/control'
--- debian/control	2014-04-24 13:14:42 +0000
+++ debian/control	2015-02-03 23:19:21 +0000
@@ -18,6 +18,7 @@
 Architecture: any
 Depends: ${misc:Depends}, ${shlibs:Depends}
 Enhances: switchboard
+Recommends: elementary-dpms-helper
 Description: Manage security and privacy
  Switchboard plug for managing the security and privacy of your system.
 

=== modified file 'src/LockPanel.vala'
--- src/LockPanel.vala	2014-04-24 21:51:15 +0000
+++ src/LockPanel.vala	2015-02-03 23:19:21 +0000
@@ -22,117 +22,104 @@
 
 public class SecurityPrivacy.LockPanel : Gtk.Grid {
 
-    Settings notification;
-    Settings screensaver;
+    Settings locker;
+    Settings dpms;
 
     public LockPanel () {
         column_spacing = 12;
         row_spacing = 6;
 
-        notification = new Settings ("org.gnome.desktop.notifications");
-        screensaver = new Settings ("org.gnome.desktop.screensaver");
-
-        var screen_lock_label = new Gtk.Label ("");
-        screen_lock_label.set_markup ("<b>%s</b>".printf (_("Lock screen:")));
-
-        var screen_lock_switch = new Gtk.Switch ();
-        screen_lock_switch.active = true;
-        var switch_grid = new Gtk.Grid ();
-        switch_grid.valign = Gtk.Align.CENTER;
-        switch_grid.add (screen_lock_switch);
+        locker = new Settings ("apps.light-locker");
+        dpms = new Settings ("org.pantheon.dpms");
 
         var screen_lock_combobox = new Gtk.ComboBoxText ();
-        screen_lock_combobox.append_text (_("After display turns off"));
-        screen_lock_combobox.append_text (_("30 seconds"));
-        screen_lock_combobox.append_text (_("1 minute"));
-        screen_lock_combobox.append_text (_("2 minutes"));
-        screen_lock_combobox.append_text (_("3 minutes"));
+        screen_lock_combobox.append_text (_("Never"));
         screen_lock_combobox.append_text (_("5 minutes"));
-        screen_lock_combobox.append_text (_("10 minutes"));
+        screen_lock_combobox.append_text (_("15 minutes"));
         screen_lock_combobox.append_text (_("30 minutes"));
         screen_lock_combobox.append_text (_("1 hour"));
-        var delay = screensaver.get_uint ("lock-delay");
-        if (delay >= 3600) {
-            screen_lock_combobox.active = 8;
-        } else if (delay >= 1800) {
-            screen_lock_combobox.active = 7;
-        } else if (delay >= 600) {
-            screen_lock_combobox.active = 6;
-        } else if (delay >= 300) {
+        screen_lock_combobox.append_text (_("2 hours"));
+        var delay = dpms.get_uint ("standby-time");
+        if (delay >= 7200) {
             screen_lock_combobox.active = 5;
-        } else if (delay >= 180) {
+        } else if (delay >= 3600) {
             screen_lock_combobox.active = 4;
-        } else if (delay >= 120) {
+        } else if (delay >= 1800) {
             screen_lock_combobox.active = 3;
-        } else if (delay >= 60) {
+        } else if (delay >= 900) {
             screen_lock_combobox.active = 2;
-        } else if (delay > 0) {
+        } else if (delay >= 300) {
             screen_lock_combobox.active = 1;
-        } else {
+        } else if (delay >= 0) {
             screen_lock_combobox.active = 0;
         }
         screen_lock_combobox.notify["active"].connect (() => {
             switch (screen_lock_combobox.active) {
-                case 8:
-                    screensaver.set_uint ("lock-delay", 3600);
-                    break;
-                case 7:
-                    screensaver.set_uint ("lock-delay", 1800);
-                    break;
-                case 6:
-                    screensaver.set_uint ("lock-delay", 600);
-                    break;
                 case 5:
-                    screensaver.set_uint ("lock-delay", 300);
+                    dpms.set_uint ("standby-time", 7200);
                     break;
                 case 4:
-                    screensaver.set_uint ("lock-delay", 180);
+                    dpms.set_uint ("standby-time", 3600);
                     break;
                 case 3:
-                    screensaver.set_uint ("lock-delay", 120);
+                    dpms.set_uint ("standby-time", 1800);
                     break;
                 case 2:
-                    screensaver.set_uint ("lock-delay", 60);
+                    dpms.set_uint ("standby-time", 900);
                     break;
                 case 1:
-                    screensaver.set_uint ("lock-delay", 30);
+                    dpms.set_uint ("standby-time", 300);
                     break;
                 default:
-                    screensaver.set_uint ("lock-delay", 0);
+                    dpms.set_uint ("standby-time", 0);
                     break;
             }
-        });
-
-        var ask_checkbutton = new Gtk.CheckButton.with_label (_("Ask for my password to unlock"));
-        ask_checkbutton.notify["active"].connect (() => {
-            screensaver.set_boolean ("ubuntu-lock-on-suspend", ask_checkbutton.active);
-        });
-        ask_checkbutton.active = screensaver.get_boolean ("ubuntu-lock-on-suspend");
-        var notification_checkbutton = new Gtk.CheckButton.with_label (_("Show notifications on lockscreen"));
-        notification_checkbutton.active = notification.get_boolean ("show-in-lock-screen");
-        notification_checkbutton.notify["active"].connect (() => {
-            notification.set_boolean ("show-in-lock-screen", notification_checkbutton.active);
-        });
-
-        screen_lock_switch.notify["active"].connect (() => {
-            screen_lock_combobox.sensitive = screen_lock_switch.active;
-            ask_checkbutton.sensitive = screen_lock_switch.active;
-            notification_checkbutton.sensitive = screen_lock_switch.active;
-            screensaver.set_boolean ("lock-enabled", screen_lock_switch.active);
-        });
-        screen_lock_switch.active = screensaver.get_boolean ("lock-enabled");
-
-        var fake_grid_left = new Gtk.Grid ();
-        fake_grid_left.hexpand = true;
-        var fake_grid_right = new Gtk.Grid ();
-        fake_grid_right.hexpand = true;
-
-        attach (fake_grid_left, 0, 0, 1, 1);
-        attach (screen_lock_label, 1, 0, 1, 1);
-        attach (switch_grid, 2, 0, 1, 1);
-        attach (screen_lock_combobox, 3, 0, 1, 1);
-        attach (ask_checkbutton, 2, 1, 2, 1);
-        //attach (notification_checkbutton, 2, 2, 2, 1);
-        attach (fake_grid_right, 4, 0, 1, 1);
+
+            /* the set above races with the get in elementary-dpms-helper */
+            Settings.sync ();
+
+            try {
+                Process.spawn_async (null, { "elementary-dpms-helper" },
+                                     Environ.get (), SpawnFlags.SEARCH_PATH, null, null);
+            } catch (SpawnError e) {
+                warning ("Failed to reset dpms settings: %s", e.message);
+            }
+        });
+
+        var timeout_label = new Gtk.Label (_("Lock screen after:"));
+
+        var lock_suspend_label = new Gtk.Label (_("Lock on sleep:"));
+        var lock_suspend_switch = new Gtk.Switch ();
+
+        /* Synchronize lock_suspend_switch and GSettings value */
+        lock_suspend_switch.active = locker.get_boolean ("lock-on-suspend");
+        locker.bind ("lock-on-suspend", lock_suspend_switch, "active", SettingsBindFlags.DEFAULT);
+
+        timeout_label.margin_top = 15;
+        lock_suspend_label.margin_bottom = 15;
+        screen_lock_combobox.margin_top = 10;
+        lock_suspend_switch.margin_bottom = 10;
+
+        lock_suspend_label.halign = Gtk.Align.END;
+        timeout_label.halign = Gtk.Align.END;
+        lock_suspend_switch.halign = Gtk.Align.START;
+        screen_lock_combobox.halign = Gtk.Align.START;
+
+        var grid_left = new Gtk.Grid ();
+        grid_left.expand = true;
+        grid_left.halign = Gtk.Align.END;
+        grid_left.valign = Gtk.Align.CENTER;
+        var grid_right = new Gtk.Grid ();
+        grid_right.expand = true;
+        grid_right.halign = Gtk.Align.START;
+        grid_right.valign = Gtk.Align.CENTER;
+
+        grid_left.attach (lock_suspend_label, 0, 0, 1, 1);
+        grid_left.attach (timeout_label, 0, 1, 1, 1);
+        grid_right.attach (lock_suspend_switch, 0, 0, 1, 1);
+        grid_right.attach (screen_lock_combobox, 0, 1, 1, 1);
+
+        attach (grid_left, 0, 0, 1, 1);
+        attach (grid_right, 1, 0, 1, 1);
     }
-}
\ No newline at end of file
+}