¿Evita que las ventanas entren en suspensión cuando mi programa se está ejecutando?

Question

Tengo que evitar que Windows se quede dormido cuando mi programa se está ejecutando.

Y no solo quiero evitar el temporizador de reposo, también quiero cancelar el evento de reposo si presiono el botón de reposo o de cualquier otra manera le digo a la computadora que duerma. Por lo tanto, SetThreadExecutionState no es suficiente.

O ... en realidad no tengo que evitar que duerma completamente, solo lo demore 5-10 segundos para permitir que mi programa termine una tarea.

(sé que esto es el mal comportamiento del programa, pero es sólo para uso personal.)

Answer 1

Tuve un problema como este con un dispositivo de hardware conectado a través de USB. XP/Vista dormiría/hibernaría justo en el medio de ... Genial dices, cuando se reanuda puede continuar. Si el hardware todavía está conectado !!! Los usuarios tienen la costumbre de sacar los cables cuando les da la gana.

que necesita para manejar XP y Vista

Bajo trampa XP el WM_POWERBROADCAST y buscar la wparam PBT_APMQUERYSUSPEND.

// See if bit 1 is set, this means that you can send a deny while we are busy 
    if (message.LParam & 0x1) 
    { 
     // send the deny message 
     return BROADCAST_QUERY_DENY; 
    } // if 
    else 
    { 
     return TRUE; 
    } // else 

Bajo Vista utilizan SetThreadExecutionState como esto

// try this for vista, it will fail on XP 
if (SetThreadExecutionState(ES_CONTINUOUS | ES_SYSTEM_REQUIRED | ES_AWAYMODE_REQUIRED) == NULL) 
{ 
    // try XP variant as well just to make sure 
    SetThreadExecutionState(ES_CONTINUOUS | ES_SYSTEM_REQUIRED); 
} // if 

y cuando la aplicación ha terminado de configurarlo de nuevo a normal

// set state back to normal 
SetThreadExecutionState(ES_CONTINUOUS); 

Answer 2

¿Qué hay de despertar una copia de seguridad si se va a dormir?

http://www.enterprisenetworksandservers.com/monthly/art.php?1049

Answer 3

La misma técnica se aplica como para prevenir el protector de pantalla debe ser utilizado. Ver Programmatically prevent Windows screensaver from starting.

Tenga en cuenta que algunas configuraciones de seguridad pueden anular esto (forzar que las computadoras se bloqueen después de un cierto tiempo).

Answer 4

Uso de las funciones PowerCreateRequest, PowerSetRequest y PowerClearRequest es el método preferido . Detalles y código de ejemplo (C/C#) están en el interior http://msdn.microsoft.com/en-us/library/windows/hardware/gg463205.aspx

Answer 5

Después de considerar la respuesta de vim

"Uso PowerCreateRequest, PowerSetRequest, y PowerClearRequest funciones es el método preferido."

con el AvailabilityRequests.docx vinculado en msdn que es agotador para entrar en ella (demasiado para leer), me han buscado en la web para un ejemplo concreto en c# que se basa en la PowerCreateRequest y se encontró http://go4answers.webhost4life.com/Example/problem-monitor-wakeup-service-windows7-12092.aspx [EDITAR 2016 - ya no está disponible]

copiado y adaptado a mis necesidades (PInvoke de CloseHandle copiado de msdn):

using System.Runtime.InteropServices; 

    #region prevent screensaver, display dimming and automatically sleeping 
    POWER_REQUEST_CONTEXT _PowerRequestContext; 
    IntPtr _PowerRequest; //HANDLE 

    // Availability Request Functions 
    [DllImport("kernel32.dll")] 
    static extern IntPtr PowerCreateRequest(ref POWER_REQUEST_CONTEXT Context); 

    [DllImport("kernel32.dll")] 
    static extern bool PowerSetRequest(IntPtr PowerRequestHandle, PowerRequestType RequestType); 

    [DllImport("kernel32.dll")] 
    static extern bool PowerClearRequest(IntPtr PowerRequestHandle, PowerRequestType RequestType); 

    [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true, ExactSpelling = true)] 
    internal static extern int CloseHandle(IntPtr hObject); 

    // Availablity Request Enumerations and Constants 
    enum PowerRequestType 
    { 
     PowerRequestDisplayRequired = 0, 
     PowerRequestSystemRequired, 
     PowerRequestAwayModeRequired, 
     PowerRequestMaximum 
    } 

    const int POWER_REQUEST_CONTEXT_VERSION = 0; 
    const int POWER_REQUEST_CONTEXT_SIMPLE_STRING = 0x1; 
    const int POWER_REQUEST_CONTEXT_DETAILED_STRING = 0x2; 

    // Availablity Request Structures 
    // Note: Windows defines the POWER_REQUEST_CONTEXT structure with an 
    // internal union of SimpleReasonString and Detailed information. 
    // To avoid runtime interop issues, this version of 
    // POWER_REQUEST_CONTEXT only supports SimpleReasonString. 
    // To use the detailed information, 
    // define the PowerCreateRequest function with the first 
    // parameter of type POWER_REQUEST_CONTEXT_DETAILED. 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] 
    public struct POWER_REQUEST_CONTEXT 
    { 
     public UInt32 Version; 
     public UInt32 Flags; 
     [MarshalAs(UnmanagedType.LPWStr)] 
     public string 
      SimpleReasonString; 
    } 

    [StructLayout(LayoutKind.Sequential)] 
    public struct PowerRequestContextDetailedInformation 
    { 
     public IntPtr LocalizedReasonModule; 
     public UInt32 LocalizedReasonId; 
     public UInt32 ReasonStringCount; 
     [MarshalAs(UnmanagedType.LPWStr)] 
     public string[] ReasonStrings; 
    } 

    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] 
    public struct POWER_REQUEST_CONTEXT_DETAILED 
    { 
     public UInt32 Version; 
     public UInt32 Flags; 
     public PowerRequestContextDetailedInformation DetailedInformation; 
    } 
    #endregion 



    /// <summary> 
    /// Prevent screensaver, display dimming and power saving. This function wraps PInvokes on Win32 API. 
    /// </summary> 
    /// <param name="enableConstantDisplayAndPower">True to get a constant display and power - False to clear the settings</param> 
    private void EnableConstantDisplayAndPower(bool enableConstantDisplayAndPower) 
    { 
     if (enableConstantDisplayAndPower) 
     { 
      // Set up the diagnostic string 
      _PowerRequestContext.Version = POWER_REQUEST_CONTEXT_VERSION; 
      _PowerRequestContext.Flags = POWER_REQUEST_CONTEXT_SIMPLE_STRING; 
      _PowerRequestContext.SimpleReasonString = "Continuous measurement"; // your reason for changing the power settings; 

      // Create the request, get a handle 
      _PowerRequest = PowerCreateRequest(ref _PowerRequestContext); 

      // Set the request 
      PowerSetRequest(_PowerRequest, PowerRequestType.PowerRequestSystemRequired); 
      PowerSetRequest(_PowerRequest, PowerRequestType.PowerRequestDisplayRequired); 
     } 
     else 
     { 
      // Clear the request 
      PowerClearRequest(_PowerRequest, PowerRequestType.PowerRequestSystemRequired); 
      PowerClearRequest(_PowerRequest, PowerRequestType.PowerRequestDisplayRequired); 

      CloseHandle(_PowerRequest); 
     } 
    }