Como posso evitar um bloqueio de ecrã reforçado com políticas no Windows 7?

Se o Windows Media Player ainda estiver instalado, você pode reproduzir um vídeo em loop e minimizá-lo (os vídeos “Wildlife” de amostra funcionam bem para isso). Por defeito, enquanto um vídeo estiver a ser reproduzido, o ecrã não fica bloqueado.

Eu uso um script que intitulo idle.vbs:

Dim objResult

Set objShell = WScript.CreateObject("WScript.Shell")    

Do While True
  objResult = objShell.sendkeys("{NUMLOCK}{NUMLOCK}")
  Wscript.Sleep (6000)
Loop

A cada seis segundos, isto alterna rapidamente o numlock no teclado, fazendo com que o Windows acredite que alguém está a interagir com o teclado, impedindo o bloqueio do ecrã. Isto corre no Windows vanilla, não precisa de ferramentas de desenvolvimento ou scripting para o utilizar, basta fazer um ficheiro de texto com .vbs como extensão e fazer duplo clique (ou colocá-lo nos seus itens de arranque).

Edit: pode colocar este script nos seus itens de arranque com

choco install IdleVbs -source https://www.myget.org/F/joshrivers-utility/

Para mais informações sobre o instalador Choclatey (choco) CLI veja: https://chocolatey.org/

Outra opção é o programa freeware Caffeine . É gratuito também para uso comercial. A partir da página inicial do programa:

Se tiver problemas com o bloqueio do seu PC ou se for dormir, a cafeína vai mantê-lo acordado. Funciona através da simulação de um pressionamento de teclas a cada 59 segundos, para que a sua máquina pense que ainda está a trabalhar no teclado, pelo que não irá bloquear o ecrã nem activar o protector de ecrã.

Cafeína funciona através da simulação de um evento com a tecla F15 a cada 59 segundos. De todas as teclas disponíveis, a F15 é provavelmente a menos intrusiva (nunca vi um teclado de PC com essa tecla!), e a menos susceptível de interferir com o seu trabalho.

Esta solução pronta a usar também lhe permite controlar quando o deve activar e desactivar:

Clicar duas vezes no ícone do programa esvazia a cafeteira, que é o que o ícone representa, e desactiva temporariamente o programa. Fazendo um duplo clique novamente, volta a encher a cafeteira e mantém a sua máquina acordada.

Você pode criar um script AutoIt para pressionar continuamente uma tecla não utilizada (por exemplo, faça-o alternar o num lock, scroll lock), dormir por um minuto ou mais, e repetir. Em alternativa, se usar muito o teclado, pode fazê-lo mover o rato por um pixel em qualquer direcção.

Se não quiser que funcione continuamente, pode também lançar o script como uma tarefa agendada (se tiver acesso) para lançar depois de o computador estar inactivo há algum tempo.

E este é um script muito simples para executar um movimento invisível do rato, se não quiser entrar na sintaxe AutoIt:

While True
   Local $pos = MouseGetPos()
   MouseMove($pos[0]-1, $pos[1]-1, 0)
   MouseMove($pos[0], $pos[1], 0)
   Sleep(540000)
WEnd

Este script move o cursor do rato por um pixel na direcção ascendente-esquerda e depois devolve-o, depois dorme durante 9 minutos (540000 milissegundos). Quando o script está a correr, pode ver o ícone AutoIt no tabuleiro. Pode pará-lo clicando com o botão direito do rato neste ícone e escolhendo a opção correspondente.

Para fazer um script, instale o AutoIt, clique com o botão direito do rato em qualquer pasta e escolha New > AutoIt v3 Script, dê-lhe um nome, clique com o botão direito do rato neste novo script, escolha Edit, cole o código fornecido acima e guarde. Pode até compilá-lo para .exe (novamente, a partir do menu de contexto) para iniciar, por exemplo, a partir do Windows Scheduler.

Existe uma aplicação androide chamada “Timeout Blocker” que vibra a um intervalo e você pode colocar o seu rato sobre ela. Mas diz para não o usar no trabalho. https://play.google.com/store/apps/details?id=com.isomerprogramming.application.timeoutblocker&hl=en

Compila-a no Visual Studio ou C# Express e executa-a a partir de um prompt de comando (ou duplo clique). Requer .NET 4.0 ou superior. Faz tudo o que procura.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Threading;
using System.Runtime.InteropServices;
using System.Windows.Forms; 

namespace ImWorkin
{
    class Program
    {
        [FlagsAttribute]
        public enum EXECUTION_STATE : uint
        {
            ES_SYSTEM_REQUIRED = 0x00000001,
            ES_DISPLAY_REQUIRED = 0x00000002,
            ES_CONTINUOUS = 0x80000000
        }
        public SYSTEMTIMEOUTS TimeOuts
        {
            get { return sysTimeouts; }
        }
        public struct SYSTEMTIMEOUTS
        {
            public int BATTERYIDLETIMEOUT;
            public int EXTERNALIDLETIMEOUT;
            public int WAKEUPIDLETIMEOUT;
        }

        [DllImport("USER32.DLL", CharSet = CharSet.Unicode)]
        public static extern IntPtr FindWindow(string lpClassName, string lpWindowName);

        [DllImport("USER32.DLL")]
        public static extern bool SetForegroundWindow(IntPtr hWnd);

        [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        static extern EXECUTION_STATE SetThreadExecutionState(EXECUTION_STATE flags);

        [DllImport("user32.dll", SetLastError = true, EntryPoint ="SystemParametersInfo")]
        internal static extern int SystemParametersInfo(int uiAction, int uiParam, ref int pvParam, int fWinIni);

        private static System.Threading.Timer preventSleepTimer = null;
        public const int SPI_GETBATTERYIDLETIMEOUT = 252;
        public const int SPI_GETEXTERNALIDLETIMEOUT = 254;
        public const int SPI_GETWAKEUPIDLETIMEOUT = 256;
        public static int Counter = 0;
        public static int timeOutinMS = 0;
        public static int batteryIdleTimer;
        public static int externalIdleTimer;
        public static int wakeupIdleTimer;
        public static SYSTEMTIMEOUTS sysTimeouts;

        static void Main(string[] args)
        {
            Console.WriteLine("You are about to be workin!! Just a moment...I need to calculate a few values.");
            string dots = string.Empty;
            for (int i =2; i < 60; i++)
            {
                dots = "";
                for (int ii = 0; ii < i; ii++)
                {
                    dots = dots + ".";
                }
                Thread.Sleep(100);
                Console.Clear();
                Console.WriteLine("You are about to be workin!! Just a moment...I need to calculate a few values.");
                Console.WriteLine(dots);
            }

            GetSystemTimeOuts();

            if (timeOutinMS < sysTimeouts.BATTERYIDLETIMEOUT)
                timeOutinMS = sysTimeouts.BATTERYIDLETIMEOUT;
            if (timeOutinMS < sysTimeouts.EXTERNALIDLETIMEOUT)
                timeOutinMS = sysTimeouts.EXTERNALIDLETIMEOUT;
            if (timeOutinMS < sysTimeouts.WAKEUPIDLETIMEOUT)
                timeOutinMS = sysTimeouts.WAKEUPIDLETIMEOUT;

            if (timeOutinMS == 0)
                timeOutinMS = 30;

            DisableDeviceSleep();
            Console.WriteLine("");
            Console.WriteLine("");
            Console.WriteLine("OK. I have calculated your computers timeout periods and set the ");
            Console.WriteLine("necessary hooks. Your computer will not shut off the monitor, will");
            Console.WriteLine("show active in any chat programs,the screensaver is disabled and ");
            Console.WriteLine("the computer will not lock! Anyone looking at you eaither locally ");
            Console.WriteLine("or remotely will think you are hard at work.");
            Console.WriteLine("");
            Console.WriteLine("Now go do something fun...I got your back ;)");
            Console.WriteLine("Oh yeah....if you close this window OR press `q' in this ");
            Console.WriteLine("window you are going to have to actually work.");
            Console.WriteLine("");
            Console.WriteLine("");
            Console.WriteLine("This text will disappear in a 30 seconds. Just in case someone comes ");
            Console.WriteLine("by and reads your screen!");
            Console.WriteLine("");
            Console.WriteLine("");
            Console.WriteLine("Need custom coding? Kenneth.gore@gmail.com");
            while (Console.KeyAvailable == false)
            {
                Thread.Sleep(250);
                ConsoleKeyInfo cki = Console.ReadKey(true);

                if (cki.KeyChar == 'q')
                    break;
            }

        }

        public static void DisableDeviceSleep()
        {
           SetThreadExecutionState(EXECUTION_STATE.ES_SYSTEM_REQUIRED | EXECUTION_STATE.ES_DISPLAY_REQUIRED | EXECUTION_STATE.ES_CONTINUOUS);
           preventSleepTimer = new System.Threading.Timer(new TimerCallback(PokeDeviceToKeepAwake), null, 0, timeOutinMS * 1000);
        }

        public static void EnableDeviceSleep()
        {

           preventSleepTimer.Dispose();
           preventSleepTimer = null;

        }

        private static void PokeDeviceToKeepAwake(object extra)
        {

            Counter++;
            try
            {
                   SetThreadExecutionState(EXECUTION_STATE.ES_SYSTEM_REQUIRED | EXECUTION_STATE.ES_DISPLAY_REQUIRED | EXECUTION_STATE.ES_CONTINUOUS);
                   IntPtr Handle = FindWindow("SysListView32", "FolderView");

                   if (Handle == IntPtr.Zero)
                   {
                       SetForegroundWindow(Handle);
                       SendKeys.SendWait("%1");
                   }

                   if (Counter > 1)
                       Console.Clear();
            } 
            catch 
            {

            }
        }

        public static void GetSystemTimeOuts()  
        {
            sysTimeouts.BATTERYIDLETIMEOUT = -2;
            sysTimeouts.EXTERNALIDLETIMEOUT = -2;
            sysTimeouts.WAKEUPIDLETIMEOUT = -2;

            if (SystemParametersInfo(SPI_GETBATTERYIDLETIMEOUT, 0, ref batteryIdleTimer, 0) == 1)
                sysTimeouts.BATTERYIDLETIMEOUT = batteryIdleTimer;
            else
                sysTimeouts.BATTERYIDLETIMEOUT = -1;

            if (SystemParametersInfo(SPI_GETEXTERNALIDLETIMEOUT, 0, ref externalIdleTimer, 0) == 1)
                sysTimeouts.EXTERNALIDLETIMEOUT = externalIdleTimer;
            else
                sysTimeouts.EXTERNALIDLETIMEOUT = -1;

            if (SystemParametersInfo(SPI_GETWAKEUPIDLETIMEOUT, 0, ref wakeupIdleTimer, 0) == 1)
                sysTimeouts.WAKEUPIDLETIMEOUT = wakeupIdleTimer;
            else
                sysTimeouts.WAKEUPIDLETIMEOUT = -1;

        }
    }
}

Gosto de utilizar simples* e integradas opções ( nenhum software adicional* ), como um powerhell script (obrigado https://dmitrysotnikov.wordpress.com/2009/06/29/prevent-desktop-lock-or-screensaver-with-powershell/ ) que utiliza o “f15” como a chave do sucesso (thx para a cafeína. É de facto menos interferente)

param($minutes = 180)

write "... screen will be awake for $minutes"

 $myshell = New-Object -com "Wscript.Shell"

 for ($i = 0; $i -lt $minutes; $i++) {
 write "... screen will be awake for" ($minutes-$i)
 Start-Sleep -Seconds 60    
 $myshell.sendkeys("{F15}")
}

Coloque isto num myScriptName.ps1 e inicie-o via atalho ou linha de comando:C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe -nop "C:\Users\myUser\Desktop\myScriptName.ps1"

UPDATE: Talvez tenha havido alguma alteração por parte do administrador, mas isto já não funciona para mim Agora tenho de usar um autohotkey-script da NBirnel: https://github.com/nbirnel/nosleep - este trabalho perfeito , porque move o rato (sem distrair nenhum trabalho)

No meu caso apenas esta linha fez o truque:

SendKeys.Send("{CAPSLOCK}");

Basta colocá-lo no evento Timer_Tick e definir o intervalo de tempo para, por exemplo, 60000ms.

Mouse Jiggler pode ser uma opção https://mousejiggler.codeplex.com/

A forma correcta de lidar com isto é:

• entrar no registo onde a política é
• definir o valor para o que quiser
• e alterar as permissões da chave de registo
• apenas Deny* escrever acesso a qualquer pessoa excepto a si

Deve desactivar o “screen lock”/“sleep mode” a partir do painel de controlo > opções de alimentação > alterar as definições do plano. Clique na opção “colocar o computador em modo de espera” e seleccione “nunca”.