Editar

Question

Recientemente actualicé de 14.04 Trusty a 16.04 Xenial. Antes de la actualización, utilicé el caffeine-plusícono indicador para indicarle a mi computadora portátil cuándo podía dormir. El modo que normalmente usaba era tener la cafeína habilitada para que la computadora solo entrara en modo de suspensión/suspensión cuando la tapa estuviera cerrada. Sin embargo, hubo ocasiones en las que quería poder dejar que el temporizador de inactividad tuviera el efecto deseado.

Desde la actualización, Caffeine ya no parece hacer nada. Puedo dejar mi computadora con un proceso de larga duración, manteniendo deliberadamente la tapa abierta, solo para regresar y encontrarla inactiva y el proceso sin terminar.

¿Cómo puedo recuperar el comportamiento anterior? Tenga en cuenta que estoy buscando unpalanca, no un cambio permanente. Como palanca, debería tener una indicación visual de si está habilitado o no. Un ícono indicador sería genial.

Nota

La búsqueda que hice antes de hacer esta pregunta arrojó: a) publicaciones antiguas (obsoletas) sobre cómo usar cafeína, ob) deshabilitar permanentemente la suspensión para solucionar varios errores de hardware. Mi pregunta es simplemente sobre restaurar la funcionalidad que tenía en 14.04, tema que no encontré abordado.

Answer 1

Editar

Después de un poco de trabajo, escribí una solución más completa y fácil de usar que la que se encuentra a continuación. Puededescargar el programaen GitHub. También necesitarás instalar las dependencias:

sudo apt install xdotool xprintidle

Respuesta original

Después de que Jacob Vlijm me señalara hacia unsolución parcial, combiné una versión modificada de su guión con fragmentos de cafeína y algo de mi propio código y se me ocurrió un reemplazo para cafeína.

Instrucciones

1. Asegúrese de que los paquetes necesarios estén instalados. Nota: caffeine-plusse utiliza sólo para iconos. Si no le importan los íconos adecuados, no los necesita.

   sudo apt install caffeine-plus xprintidle xdotool
   

2. Guarde el siguiente script en algún lugar y hágalo ejecutable.

   #!/usr/bin/python3
   # coding=utf-8
   #
   # Copyright © 2016 Scott Severance
   # Code mixed in from Caffeine Plus and Jacob Vlijm
   #
   # 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 3 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/>.
   
   import argparse
   import os
   import signal
   import time
   from subprocess import Popen, check_output, call
   import gi
   gi.require_version('Gtk', '3.0')
   gi.require_version('AppIndicator3', '0.1')
   from gi.repository import GObject, Gtk, AppIndicator3
   
   class SleepInhibit(GObject.GObject):
   
       def __init__(self):
           GObject.GObject.__init__(self)
           self.inhibited = False
           self._add_indicator()
           self.inhibit_proc = None
   
       def _add_indicator(self):
           self.AppInd = AppIndicator3.Indicator.new("sleep-inhibit-off",
                                                     "sleep-inhibit",
                                                     AppIndicator3.IndicatorCategory.APPLICATION_STATUS)
           self.AppInd.set_status(AppIndicator3.IndicatorStatus.ACTIVE)
           self.AppInd.set_icon ("caffeine-cup-empty")
   
           self._build_indicator_menu(self.AppInd)
   
       def _build_indicator_menu(self, indicator):
           menu = Gtk.Menu()
   
           menu_item = Gtk.MenuItem("Toggle Sleep Inhibition")
           menu.append(menu_item)
           menu_item.connect("activate", self.on_toggle)
           menu_item.show()
   
           menu_item = Gtk.MenuItem("Quit")
           menu.append(menu_item)
           menu_item.connect("activate", self.on_quit)
           menu_item.show()
   
           indicator.set_menu(menu)
   
       def on_toggle(self, menuitem):
           self.inhibited = not self.inhibited
           self.flip_switch()
   
       def on_quit(self, menuitem):
           if self.inhibit_proc:
               self.kill_inhibit_proc()
           exit(0)
   
       def _set_icon_disabled(self):
           self.AppInd.set_icon('caffeine-cup-empty')
   
       def _set_icon_enabled(self):
           self.AppInd.set_icon('caffeine-cup-full')
   
       def flip_switch(self):
           if self.inhibited:
               self._set_icon_enabled()
               self.inhibit_proc = Popen([__file__, "--mode=inhibit-process"])
           else:
               self.kill_inhibit_proc()
               self._set_icon_disabled()
   
       def kill_inhibit_proc(self):
           self.inhibit_proc.terminate()
           self.inhibit_proc.wait()
           self.inhibit_proc = None
   
   def inhibit():
       seconds = 120 # number of seconds to start preventing blank screen / suspend
       while True:
           try:
               curr_idle = check_output(["xprintidle"]).decode("utf-8").strip()
               if int(curr_idle) > seconds*1000:
                   call(["xdotool", "key", "Control_L"])
               time.sleep(10)
           except FileNotFoundError:
               exit('ERROR: This program depends on xprintidle and xdotool being installed.')
           except KeyboardInterrupt:
               exit(0)
   
   def parse_args():
       parser = argparse.ArgumentParser(description='''Indicator to prevent
           computer from sleeping. It depends on the commands xprintidle and
           xdotool being properly installed on your system. If they aren't
           installed already, please install them. Also, the icons are taken from
           caffeine-plus, so if it isn't installed, you will probably see a broken
           icon.''')
       mode = '''The mode can be either indicator (default) or inhibit-process. If
           mode is indicator, then an indicator icon is created. inhibit-process is
           to be called by the indicator. When sleep is inhibited, it runs,
           preventing sleep.'''
       parser.add_argument('--mode', type=str, default='indicator', help=mode)
       return parser.parse_args()
   
   def main():
       args = parse_args()
       if args.mode == 'indicator':
           signal.signal(signal.SIGINT, signal.SIG_DFL)
           GObject.threads_init()
           SleepInhibit()
           Gtk.main()
       elif args.mode == 'inhibit-process':
           inhibit()
       else:
           exit('ERROR: Invalid value for --mode!')
   
   if __name__ == '__main__':
       main()
   

3. Ejecute el script.