Changeset 491

Timestamp:

11/10/2008 10:01:23 AM (5 years ago)

Author:

lowjoel

Message:

Implemented #37: don't let the system go to sleep while executing a task.

Location:

branches/eraser6

Files:

• Manager/DirectExecutor.cs (modified) (2 diffs)
• Util/KernelAPI.cs (modified) (3 diffs)

branches/eraser6/Manager/DirectExecutor.cs

@@ -293 +293 @@
                     try
                     {
+                        //Prevent the system from sleeping.
+                        KernelAPI.SetThreadExecutionState(KernelAPI.EXECUTION_STATE.ES_CONTINUOUS |
+                            KernelAPI.EXECUTION_STATE.ES_SYSTEM_REQUIRED);
+
                         //Broadcast the task started event.
                         task.queued = false;
@@ -332 +336 @@
                     finally
                     {
+                        //Allow the system to sleep again.
+                        KernelAPI.SetThreadExecutionState(KernelAPI.EXECUTION_STATE.ES_CONTINUOUS |
+                            KernelAPI.EXECUTION_STATE.ES_SYSTEM_REQUIRED);
+
                         //If the task is a recurring task, reschedule it since we are done.
                         if (task.Schedule is RecurringSchedule)

branches/eraser6/Util/KernelAPI.cs

@@ -301 +301 @@
             /// </summary>
             private ulong ullAvailExtendedVirtual;
-
-            public override int GetHashCode()
-            {
-                throw new NotImplementedException();
-            }
-
-            public override bool Equals(Object obj)
-            {
-                throw new NotImplementedException();
-            }
-
-            public static bool operator ==(MEMORYSTATUSEX x, MEMORYSTATUSEX y)
-            {
-                throw new NotImplementedException();
-            }
-
-            public static bool operator !=(MEMORYSTATUSEX x, MEMORYSTATUSEX y)
-            {
-                throw new NotImplementedException();
-            }
-        }
+        }
 
         /// <summary>
@@ -433 +413 @@
             /// </summary>
             public ushort processorRevision;
-
-            public override int GetHashCode()
-            {
-                throw new NotImplementedException();
-            }
-
-            public override bool Equals(Object obj)
-            {
-                throw new NotImplementedException();
-            }
-
-            public static bool operator ==(SYSTEM_INFO x, SYSTEM_INFO y)
-            {
-                throw new NotImplementedException();
-            }
-
-            public static bool operator !=(SYSTEM_INFO x, SYSTEM_INFO y)
-            {
-                throw new NotImplementedException();
-            }
-        }
+        }
 
         /// <summary>
@@ -613 +573 @@
             /// </summary>
             public IntPtr hStdError;
-
-            public override int GetHashCode()
-            {
-                throw new NotImplementedException();
-            }
-
-            public override bool Equals(Object obj)
-            {
-                throw new NotImplementedException();
-            }
-
-            public static bool operator ==(STARTUPINFO x, STARTUPINFO y)
-            {
-                throw new NotImplementedException();
-            }
-
-            public static bool operator !=(STARTUPINFO x, STARTUPINFO y)
-            {
-                throw new NotImplementedException();
-            }
-        }
+        }
+
+        /// <summary>
+        /// Enables an application to inform the system that it is in use, thereby
+        /// preventing the system from entering sleep or turning off the display
+        /// while the application is running.
+        /// </summary>
+        /// <param name="esFlags">The thread's execution requirements. This parameter
+        /// can be one or more of the EXECUTION_STATE values.</param>
+        /// <returns>If the function succeeds, the return value is the previous
+        /// thread execution state.
+        /// 
+        /// If the function fails, the return value is NULL.</returns>
+        /// <remarks>The system automatically detects activities such as local keyboard
+        /// or mouse input, server activity, and changing window focus. Activities
+        /// that are not automatically detected include disk or CPU activity and
+        /// video display.
+        /// 
+        /// Calling SetThreadExecutionState without ES_CONTINUOUS simply resets
+        /// the idle timer; to keep the display or system in the working state,
+        /// the thread must call SetThreadExecutionState periodically.
+        /// 
+        /// To run properly on a power-managed computer, applications such as fax
+        /// servers, answering machines, backup agents, and network management
+        /// applications must use both ES_SYSTEM_REQUIRED and ES_CONTINUOUS when
+        /// they process events. Multimedia applications, such as video players
+        /// and presentation applications, must use ES_DISPLAY_REQUIRED when they
+        /// display video for long periods of time without user input. Applications
+        /// such as word processors, spreadsheets, browsers, and games do not need
+        /// to call SetThreadExecutionState.
+        /// 
+        /// The ES_AWAYMODE_REQUIRED value should be used only when absolutely
+        /// necessary by media applications that require the system to perform
+        /// background tasks such as recording television content or streaming media
+        /// to other devices while the system appears to be sleeping. Applications
+        /// that do not require critical background processing or that run on
+        /// portable computers should not enable away mode because it prevents
+        /// the system from conserving power by entering true sleep.
+        /// 
+        /// To enable away mode, an application uses both ES_AWAYMODE_REQUIRED and
+        /// ES_CONTINUOUS; to disable away mode, an application calls
+        /// SetThreadExecutionState with ES_CONTINUOUS and clears
+        /// ES_AWAYMODE_REQUIRED. When away mode is enabled, any operation that
+        /// would put the computer to sleep puts it in away mode instead. The computer
+        /// appears to be sleeping while the system continues to perform tasks that
+        /// do not require user input. Away mode does not affect the sleep idle
+        /// timer; to prevent the system from entering sleep when the timer expires,
+        /// an application must also set the ES_SYSTEM_REQUIRED value.
+        /// 
+        /// The SetThreadExecutionState function cannot be used to prevent the user
+        /// from putting the computer to sleep. Applications should respect that
+        /// the user expects a certain behavior when they close the lid on their
+        /// laptop or press the power button.
+        /// 
+        /// This function does not stop the screen saver from executing. 
+        /// </remarks>
+        [DllImport("Kernel32.dll")]
+        public static extern EXECUTION_STATE SetThreadExecutionState(EXECUTION_STATE esFlags);
+
+        /// <summary>
+        /// Execution state values to be used in conjuction with SetThreadExecutionState
+        /// </summary>
+        public enum EXECUTION_STATE : uint
+        {
+            /// <summary>
+            /// Enables away mode. This value must be specified with ES_CONTINUOUS.
+            /// 
+            /// Away mode should be used only by media-recording and media-distribution
+            /// applications that must perform critical background processing on
+            /// desktop computers while the computer appears to be sleeping.
+            /// See remarks.
+            /// 
+            /// Windows Server 2003 and Windows XP/2000: ES_AWAYMODE_REQUIRED is
+            /// not supported.
+            /// </summary>
+            ES_AWAYMODE_REQUIRED = 0x00000040,
+    
+            /// <summary>
+            /// Informs the system that the state being set should remain in effect
+            /// until the next call that uses ES_CONTINUOUS and one of the other
+            /// state flags is cleared.
+            /// </summary>
+            ES_CONTINUOUS = 0x80000000,
+
+            /// <summary>
+            /// Forces the display to be on by resetting the display idle timer.
+            /// </summary>
+            ES_DISPLAY_REQUIRED = 0x00000002,
+
+            /// <summary>
+            /// Forces the system to be in the working state by resetting the system
+            /// idle timer.
+            /// </summary>
+            ES_SYSTEM_REQUIRED = 0x00000001,
+    
+            /// <summary>
+            /// This value is not supported. If ES_USER_PRESENT is combined with
+            /// other esFlags values, the call will fail and none of the specified
+            /// states will be set.
+            /// 
+            /// Windows Server 2003 and Windows XP/2000: Informs the system that a
+            /// user is present and resets the display and system idle timers.
+            /// ES_USER_PRESENT must be called with ES_CONTINUOUS.
+            /// </summary>
+            ES_USER_PRESENT = 0x00000004
+        }
     }
 }