Comando para suspender ou hibernar - Linux • Do bit Ao Byte

Um dia desses resolvi trocar a interface gráfica de Cinammon para XFCE, afim de economizar recursos (bateria, video e CPU) do meu note. Então, ao trocar de interface imediatamente senti a falta de um recurso que para mim era fundamental; o travamento de tela ao suspender. Antes de seguirmos com a leitura – sim, existe a configuração no painel do XFCE, mas de imediato resolvi fazer um programa para travar a tela antes de de suspender – além de agilizar a suspensão para a memória.

pm-suspend e família
Claro que há vários programas para essa finalidade e, para travar a tela, escolhi o xscreensaver, pela beleza e pela opção de utilizá-lo por linha para travar a tela. Mas o pm é uma ferramenta de console que serve tanto para suspender como hibernar.

Liberdade
E software livre é isso; liberdade para escolher como executar uma tarefa. Tanto que entre as opções, da mais simples à mais sofisticada, escolhi fazê-lo em Qt. Mas aqui vou exemplificar todas as opções que pensei para que você sinta o prazer que é trabalhar em uma plataforma livre como o é GNU/Linux.

Como saber se meu sistema está suportando suspend e hibernate
No arquivo /sys/power/state você deve encontrar as opções suportadas com o comando cat:


viking@djames# cat /sys/power/state
mem disk
viking@djames#

viking@djames# cat /sys/power/state

mem disk

viking@djames#

No meu note mostrou-se o suporte a suspend para memória e disco (sendo disco chamado de ‘hibernação’).

Travando a tela com xscreensaver
Para travar a tela na linha de comando, digita-se:


xscreensaver-command -lock

xscreensaver-command -lock

Então, para que quando meu note volte de suspender esteja travado, executo primeiro o lock da tela seguido do suspend. Seja lá qual for a linguagem de programação escolhida, após programado bastará criar um atalho para que o programa responda a um click do usuário. Para fazer esse programa em:

Shell Script


#!/bin/sh
#travar a tela
xscreensaver-command -lock&
#Suspender para a memoria
echo "mem" &gt; /sys/power/state

#!/bin/sh

#travar a tela

xscreensaver-command -lock&

#Suspender para a memoria

echo "mem" > /sys/power/state

Python


#!/usr/bin/env python
import os
os.system("xscreensaver-command -lock&");
arquivo = open('/sys/power/state', 'w')
arquivo.write("mem")
arquivo.close()

#!/usr/bin/env python

import os

os.system("xscreensaver-command -lock&");

arquivo = open('/sys/power/state', 'w')

arquivo.write("mem")

arquivo.close()


#include &lt;stdio.h&gt;
void main(){
    system("xscreensaver-command -lock&");
    FILE *file;
    file = fopen("/sys/power/state","w"); 
    fprintf(file,"%s","mem");
    fclose(file);
}

#include <stdio.h>

void main(){

system("xscreensaver-command -lock&");

FILE *file;

file = fopen("/sys/power/state","w");

fprintf(file,"%s","mem");

fclose(file);

}

Qt
Criei um novo projeto Qt Console Application, e criei uma classe para adicionar um único método (porque eu quis fazer assim e ponto):

<core>
#classe Suspender.cpp, com método void SuspendToRAM() público
void Suspender::SuspendToRAM()
{
    //protetor de tela
    QProcess screensaver;
    QString command;
    QStringList args;
    command = "xscreensaver-command";
    args    &gt;&gt; "-lock";
    screensaver.execute(command,args);
    screensaver.waitForFinished();
    //suspender
    QFile stateFile("/sys/power/state");
    if (!stateFile.open(QIODevice::WriteOnly | QIODevice::Text)){
        qDebug() &gt;&gt; "Couldnt open...";
        return;
    }
    QTextStream out(&stateFile);
    out &gt;&gt; "mem";
    stateFile.close();
}

<core>

#classe Suspender.cpp, com método void SuspendToRAM() público

void Suspender::SuspendToRAM()

{

//protetor de tela

QProcess screensaver;

QString command;

QStringList args;

command = "xscreensaver-command";

args >> "-lock";

screensaver.execute(command,args);

screensaver.waitForFinished();

//suspender

QFile stateFile("/sys/power/state");

if (!stateFile.open(QIODevice::WriteOnly | QIODevice::Text)){

qDebug() >> "Couldnt open...";

return;

}

QTextStream out(&stateFile);

out >> "mem";

stateFile.close();

}

E no main.cpp:



		
		
			
			
Shell
			
			//include do header suspender
#include "suspender.h"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    ///criação do objeto
    Suspender suspend;
    //chamada do método
    suspend.SuspendToRAM();
    //comentado o loop, assim a aplicação executa e sai (porque eu quis assim)
    //return a.exec();
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						//include do header suspender
#include "suspender.h"
 
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    ///criação do objeto
    Suspender suspend;
    //chamada do método
    suspend.SuspendToRAM();
    //comentado o loop, assim a aplicação executa e sai (porque eu quis assim)
    //return a.exec();
}

Depois como já citei, criei o atalho no canto da barra de tarefas com o ícone “Zzz”. Executando dessa maneira o suspend é muito mais rápido que o da própria interface, teste e comprove. E viva a liberdade!

Se gostou, não deixe de compartilhar; dê seu like no video e inscreva-se no nosso canal Do bit Ao Byte Brasil no YouTube.

Prefere seguir-nos pelo facebook? Basta curtir aqui.

Prefere twitter? @DobitAoByte.

Próximo post a caminho!

Djames Suhanko

Djames Suhanko é Perito Forense Digital. Já atuou com deployer em sistemas de missão critica em diversos países pelo mundão.

Programador Shell, Python, C, C++ e Qt, tendo contato com embarcados ( ora profissionalmente, ora por lazer ) desde 2009.

Do bit Ao Byte

Comando para suspender ou hibernar – Linux

-

Relacionado

Compartilhe com:

Relacionado