web-dev-qa-db-fra.com

Empêcher les fenêtres de se mettre en veille lorsque mon programme est en cours d'exécution?

Je dois empêcher Windows de se mettre en veille lorsque mon programme est en cours d'exécution.

Et je ne veux pas seulement empêcher la minuterie de mise en veille, je veux également annuler l'événement de mise en veille si j'appuie sur le bouton de mise en veille ou de toute autre manière en disant activement à l'ordinateur de se mettre en veille. Par conséquent, SetThreadExecutionState n'est pas suffisant.

Ou ... Je n'ai pas vraiment à empêcher le sommeil complètement, il suffit de le retarder de 5 à 10 secondes pour permettre à mon programme de terminer une tâche.

(Je sais que c'est un mauvais comportement du programme mais c'est uniquement pour un usage personnel.)

windowswinapisleep
37
ping

J'ai eu un problème comme celui-ci avec un périphérique matériel connecté via USB. XP/Vista s'endormirait/hibernerait en plein milieu de ... Super vous dites, quand il reprend il peut continuer. Si le matériel est toujours connecté !!! Les utilisateurs ont l'habitude de tirer les câbles quand ils en ont envie.

Vous devez gérer XP et Vista

Sous XP piège le WM_POWERBROADCAST et recherchez le 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

Sous Vista, utilisez SetThreadExecutionState comme ceci

// 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

et lorsque votre application a fini de la remettre à la normale

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

Après avoir considéré réponse de vim

"L'utilisation des fonctions PowerCreateRequest, PowerSetRequest et PowerClearRequest est la méthode préférée."

avec le AvailabilityRequests.docx lié sur msdn qui est épuisant pour y entrer (trop à lire), j'ai cherché sur le Web un exemple concret dans c # qui est basé sur PowerCreateRequest et trouvé http://go4answers.webhost4life.com/Example/problem-monitor-wakeup-service-windows7-12092.aspx [EDIT 2016 - n'est plus disponible]

Copié et adapté à mes besoins (PInvoke de CloseHandle copié depuis 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);
        }
    }
22
MarkusEgle

L'utilisation des fonctions PowerCreateRequest, PowerSetRequest et PowerClearRequest est la méthode préférée. Les détails et l'exemple de code (C/C #) sont à l'intérieur http://msdn.Microsoft.com/en-us/library/windows/hardware/gg463205.aspx

6
vim

La même technique s'applique que pour empêcher l'économiseur d'écran doit être utilisé. Voir empêcher par programme l'économiseur d'écran Windows de démarrer .

Notez que certains paramètres de sécurité peuvent remplacer cela (forcer les ordinateurs à se verrouiller après un certain temps en est un).

1
Zooba

Que diriez-vous de le réveiller s'il s'endort?

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

0
Greg Dean