Evitar que minha máquina durma [duplicata]

2

Eu atualizei recentemente de 14.04 Trusty para 16.04 Xenial. Antes da atualização, usei o ícone indicador caffeine-plus para informar ao meu laptop quando ele podia dormir. O modo que eu usava normalmente era ter cafeína habilitada para que o computador só dormisse / suspendesse quando a tampa estivesse fechada. No entanto, houve ocasiões em que eu queria permitir que o temporizador inativo tivesse o efeito desejado.

Desde a atualização, a cafeína não parece fazer mais nada. Eu posso deixar meu computador com um processo de longa duração, deliberadamente mantendo a tampa aberta, apenas para voltar a encontrá-lo dormindo e o processo inacabado.

Como posso recuperar o comportamento anterior? Note que estou procurando por uma alternância , não uma alteração permanente. Como uma alternância, ela deve ter uma indicação visual se está ativada ou não. Um ícone de indicador seria ótimo.

Nota

A pesquisa que fiz antes de fazer essa pergunta apareceu: a) postagens antigas (desatualizadas) sobre como usar a cafeína, ou b) desabilitar permanentemente o sono para solucionar vários erros de hardware. Minha pergunta é simplesmente sobre como restaurar a funcionalidade que eu tinha em 14.04, um tópico que não encontrei abordado.

    
por Scott Severance 06.05.2016 / 07:27

1 resposta

2

Editar

Depois de um pouco de trabalho, eu escrevi uma solução mais completa e mais fácil de usar do que a encontrada abaixo. Você pode baixar o programa no GitHub. Você também precisará instalar as dependências:

sudo apt install xdotool xprintidle

Resposta original

Depois que Jacob Vlijm me indicou um solução parcial , combinei uma versão modificada de seu roteiro com pedaços de cafeína e um pouco do meu próprio código e inventei um substituto para a cafeína.

Instruções

  1. Verifique se os pacotes necessários estão instalados. Nota: caffeine-plus é usado apenas para ícones. Se você não se importa com ícones adequados, você não precisa disso.

    sudo apt install caffeine-plus xprintidle xdotool
    
  2. Salve o script abaixo em algum lugar e torne-o executável.

    #!/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. Execute o script.

por Scott Severance 06.05.2016 / 10:14

Tags