system-sleep sleep blocker and sleep/wake event package (bug#80348)

This package provides platform-neutral interfaces to block your
system from entering idle sleep and a hook to process pre-sleep
and post-wake events.

Implementations are for D-Bus on GNU/Linux, macOS/GNUstep, and
MS-Windows.

* lisp/system-sleep.el: New package.
* src/fns.c: Qpre_sleep, Qpost_wake: New DEFSYM.
* src/nsfns.m (Fns_block_system_sleep, Fns_unblock_system_sleep)
(syms_of_nsfns): New functions.
* src/nsterm.m (applicationDidFinishLaunching): Subscribe to
pre-sleep and post-wake notifications.
(systemWillSleep, systemDidWake): New function.
* src/w32fns.c (Fw32_block_system_sleep)
(Fw32_unblock_system_sleep, Fw32_system_sleep_block_count)
(sleep_notification_callback)
(w32_register_for_sleep_notifications): New function.
(syms_of_w32fns): Sw32_unblock_system_sleep
Sw32_block_system_sleep Sw32_system_sleep_block_count: New
defsubr.
* src/w32term.h (Fw32_block_system_sleep): New extern.
* src/w32term.c (w32_initialize): Call
w32_register_for_sleep_notifications.
* doc/lispref/os.texi: Document the system-sleep package.
* doc/lispref/commands.texi: Update sleep-event special
documentation.
* etc/NEWS: Announce the new package.

6 files changed, 274 insertions, 9 deletions

diff --git a/src/fns.c b/src/fns.c
index 5c30d950cff..c29f9fa8cd1 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -6891,4 +6891,8 @@ For best results this should end in a space.  */);
   DEFSYM (QCin_place, ":in-place");
   DEFSYM (QCreverse, ":reverse");
   DEFSYM (Qvaluelt, "value<");
+
+  /* sleep-event states.  */
+  DEFSYM (Qpre_sleep, "pre-sleep");
+  DEFSYM (Qpost_wake, "post-wake");
 }
diff --git a/src/nsfns.m b/src/nsfns.m
index cf685630ab7..3d3d5ec1bde 100644
--- a/src/nsfns.m
+++ b/src/nsfns.m
@@ -3805,6 +3805,88 @@ If PROGRESS is nil, remove the progress indicator.  */)
   return Qnil;
 }
 
+/* A unique integer sleep block id and a hash map of its id to opaque
+   NSObject sleep block activity tokens.  */
+static unsigned int sleep_block_id = 0;
+static NSMutableDictionary *sleep_block_map = NULL;
+
+DEFUN ("ns-block-system-sleep",
+       Fns_block_system_sleep,
+       Sns_block_system_sleep,
+       2, 2, 0,
+       doc: /* Block system idle sleep.
+WHY is a string reason for the block.
+If ALLOW-DISPLAY-SLEEP is non-nil, block the screen from sleeping.
+Return a token to unblock this block using `ns-unblock-system-sleep',
+or nil if the block fails.  */)
+  (Lisp_Object why, Lisp_Object allow_display_sleep)
+{
+  block_input ();
+
+  NSString *reason = @"Emacs";
+  if (!NILP (why))
+    {
+      CHECK_STRING (why);
+      reason = [NSString stringWithLispString: why];
+    }
+
+  unsigned long activity_options =
+    NSActivityUserInitiated | NSActivityIdleSystemSleepDisabled;
+  if (NILP (allow_display_sleep))
+    activity_options |= NSActivityIdleDisplaySleepDisabled;
+
+  NSProcessInfo *processInfo = [NSProcessInfo processInfo];
+  NSObject *activity_id = nil;
+  if ([processInfo respondsToSelector:@selector(beginActivityWithOptions:reason:)])
+    activity_id = [[NSProcessInfo processInfo]
+                             beginActivityWithOptions: activity_options
+                                               reason: reason];
+  unblock_input ();
+
+  if (!sleep_block_map)
+    sleep_block_map = [[NSMutableDictionary alloc] initWithCapacity: 25];
+
+  if (activity_id)
+    {
+      [sleep_block_map setObject: activity_id
+                          forKey: [NSNumber numberWithInt: ++sleep_block_id]];
+      return make_fixnum (sleep_block_id);
+    }
+  else
+    return Qnil;
+}
+
+DEFUN ("ns-unblock-system-sleep",
+       Fns_unblock_system_sleep,
+       Sns_unblock_system_sleep,
+       1, 1, 0,
+       doc: /* Unblock system idle sleep.
+TOKEN is an object returned by `ns-block-system-sleep'.
+Return non-nil if the TOKEN block was unblocked.  */)
+  (Lisp_Object token)
+{
+  block_input ();
+  Lisp_Object res = Qnil;
+  CHECK_FIXNAT (token);
+  if (sleep_block_map)
+    {
+      NSNumber *key = [NSNumber numberWithInt: XFIXNAT (token)];
+      NSObject *activity_id = [sleep_block_map objectForKey: key];
+      if (activity_id)
+        {
+          NSProcessInfo *processInfo = [NSProcessInfo processInfo];
+          if ([processInfo respondsToSelector:@selector(endActivity:)])
+            {
+              [[NSProcessInfo processInfo] endActivity: activity_id];
+              res = Qt;
+            }
+          [sleep_block_map removeObjectForKey: key];
+        }
+    }
+  unblock_input ();
+  return res;
+}
+
 #ifdef NS_IMPL_COCOA
 
 DEFUN ("ns-send-items",
@@ -4091,6 +4173,8 @@ The default value is t.  */);
   defsubr (&Sns_badge);
   defsubr (&Sns_request_user_attention);
   defsubr (&Sns_progress_indicator);
+  defsubr (&Sns_block_system_sleep);
+  defsubr (&Sns_unblock_system_sleep);
 #ifdef NS_IMPL_COCOA
   defsubr (&Sns_send_items);
 #endif
diff --git a/src/nsterm.m b/src/nsterm.m
index c852b70be74..d0bbd1b4660 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -5838,15 +5838,6 @@ ns_term_init (Lisp_Object display_name)
   ns_pending_service_names = [[NSMutableArray alloc] init];
   ns_pending_service_args = [[NSMutableArray alloc] init];
 
-#if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED >= 260000
-  /* Disable problematic event processing on macOS 26 (Tahoe) to avoid
-     scrolling lag and input handling issues.  These are undocumented
-     options as of macOS 26.0.  */
-  [NSUserDefaults.standardUserDefaults
-      registerDefaults:@{@"NSEventConcurrentProcessingEnabled" : @"NO",
-        @"NSApplicationUpdateCycleEnabled" : @"NO"}];
-#endif
-
   /* Start app and create the main menu, window, view.
      Needs to be here because ns_initialize_display_info () uses AppKit classes.
      The view will then ask the NSApp to stop and return to Emacs.  */
@@ -6384,6 +6375,20 @@ ns_term_shutdown (int sig)
 #endif
 
 #ifdef NS_IMPL_COCOA
+  /* Sleep event notification.  */
+  [[[NSWorkspace sharedWorkspace] notificationCenter]
+    addObserver: self
+       selector:@selector(systemWillSleep:)
+           name: NSWorkspaceWillSleepNotification
+         object: nil];
+  [[[NSWorkspace sharedWorkspace] notificationCenter]
+    addObserver: self
+       selector: @selector(systemDidWake:)
+           name: NSWorkspaceDidWakeNotification
+         object: nil];
+#endif
+
+#ifdef NS_IMPL_COCOA
   /* Some functions/methods in CoreFoundation/Foundation increase the
      maximum number of open files for the process in their first call.
      We make dummy calls to them and then reduce the resource limit
@@ -6421,6 +6426,31 @@ ns_term_shutdown (int sig)
 #endif
 }
 
+/* Sleep event notification.  */
+
+- (void) systemWillSleep:(NSNotification *)notification
+{
+#ifdef NS_IMPL_COCOA
+  NSTRACE ("[EmacsApp systemWillSleep:]");
+  struct input_event ie;
+  EVENT_INIT (ie);
+  ie.kind = SLEEP_EVENT;
+  ie.arg = list1 (Qpre_sleep);
+  kbd_buffer_store_event (&ie);
+#endif
+}
+
+- (void) systemDidWake:(NSNotification *)notification
+{
+#ifdef NS_IMPL_COCOA
+  NSTRACE ("[EmacsApp systemDidWake:]");
+  struct input_event ie;
+  EVENT_INIT (ie);
+  ie.kind = SLEEP_EVENT;
+  ie.arg = list1 (Qpost_wake);
+  kbd_buffer_store_event (&ie);
+#endif
+}
 
 /* Termination sequences:
     C-x C-c:
diff --git a/src/w32fns.c b/src/w32fns.c
index b75bce8d1a2..3a32d046132 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -11326,6 +11326,136 @@ if the selected frame is not (yet) associated with a window handle  */)
 #endif /* WINDOWSNT */
 
 /***********************************************************************
+                     System Sleep Support
+ ***********************************************************************/
+
+typedef ULONG (WINAPI * SetThreadExecutionState_Proc)
+  (IN ULONG);
+static SetThreadExecutionState_Proc SetThreadExecutionState_fn = NULL;
+
+static unsigned int sleep_block_id = 0;
+static unsigned int sleep_block_count = 0;
+
+DEFUN ("w32-block-system-sleep",
+       Fw32_block_system_sleep,
+       Sw32_block_system_sleep,
+       1, 1, 0,
+       doc: /* Block system idle sleep.
+If ALLOW-DISPLAY-SLEEP is non-nil, block the screen from sleeping.
+Return a token to unblock this block using `w32-unblock-system-sleep',
+or nil if the block fails.  */)
+  (Lisp_Object allow_display_sleep)
+{
+  if (SetThreadExecutionState_fn == NULL)
+    return Qnil;
+
+  /* ES_CONTINUOUS keeps the state until cleared.  */
+  EXECUTION_STATE new_state = ES_SYSTEM_REQUIRED | ES_CONTINUOUS;
+  if (NILP (allow_display_sleep))
+    new_state |= ES_DISPLAY_REQUIRED;
+
+  if (SetThreadExecutionState (new_state) == 0)
+    return Qnil;
+  else
+    {
+      /* One more block and next id.  */
+      ++sleep_block_count;
+      ++sleep_block_id;
+
+      /* Synthesize a token.  */
+      return make_fixnum (sleep_block_id);
+    }
+}
+
+DEFUN ("w32-unblock-system-sleep",
+       Fw32_unblock_system_sleep,
+       Sw32_unblock_system_sleep,
+       0, 0, 0,
+       doc: /* Unblock system idle sleep.
+Return non-nil if the TOKEN block was unblocked.  */)
+  (void)
+{
+  if (SetThreadExecutionState_fn == NULL)
+    return Qnil;
+
+  /* No blocks to unblock.  */
+  if (sleep_block_count == 0)
+    return Qnil;
+
+  /* One fewer block.  */
+  if (--sleep_block_count == 0
+      && SetThreadExecutionState (ES_CONTINUOUS) == 0)
+      return Qnil;
+  else
+    return Qt;
+}
+
+DEFUN ("w32-system-sleep-block-count",
+       Fw32_system_sleep_block_count,
+       Sw32_system_sleep_block_count,
+       0, 0, 0,
+       doc: /* Return the w32 sleep block count.  */)
+  (void)
+{
+  return make_fixnum (sleep_block_count);
+}
+
+typedef ULONG (CALLBACK *PMY_DEVICE_NOTIFY_CALLBACK_ROUTINE)
+  (PVOID Context,  ULONG Type,  PVOID Setting);
+
+static ULONG ALIGN_STACK
+sleep_notification_callback(PVOID _Context, ULONG Type, PVOID _Setting)
+{
+  struct input_event ie;
+  EVENT_INIT (ie);
+  ie.kind = SLEEP_EVENT;
+
+  switch (Type)
+    {
+    case PBT_APMRESUMEAUTOMATIC:
+      /* Ignore this event.  No user is present.  */
+      break;
+    case PBT_APMSUSPEND:
+      ie.arg = list1 (Qpre_sleep);
+      kbd_buffer_store_event (&ie);
+      break;
+    case PBT_APMRESUMESUSPEND:
+      ie.arg = list1 (Qpost_wake);
+      kbd_buffer_store_event (&ie);
+      break;
+    }
+  return 0;
+}
+
+typedef HPOWERNOTIFY (WINAPI * RegisterSuspendResumeNotification_Proc)
+  (IN HANDLE, IN DWORD);
+static RegisterSuspendResumeNotification_Proc RegisterSuspendResumeNotification_fn = NULL;
+
+static HPOWERNOTIFY sleep_notification_handle = 0;
+
+typedef struct _MY_DEVICE_NOTIFY_SUBSCRIBE_PARAMETERS {
+  PMY_DEVICE_NOTIFY_CALLBACK_ROUTINE Callback;
+  PVOID Context;
+} MY_DEVICE_NOTIFY_SUBSCRIBE_PARAMETERS, *PMY_DEVICE_NOTIFY_SUBSCRIBE_PARAMETERS;
+
+void
+w32_register_for_sleep_notifications()
+{
+  /* PowerRegisterSuspendResumeNotification is not a user-space call so
+     we use RegisterSuspendResumeNotification.  */
+  if (RegisterSuspendResumeNotification_fn)
+    {
+      MY_DEVICE_NOTIFY_SUBSCRIBE_PARAMETERS params;
+      params.Callback = sleep_notification_callback;
+      params.Context = NULL;
+
+      /* DEVICE_NOTIFY_CALLBACK = 2  */
+      sleep_notification_handle =
+        RegisterSuspendResumeNotification_fn (&params, 2);
+    }
+}
+
+/***********************************************************************
                             Initialization
  ***********************************************************************/
 
@@ -11834,6 +11964,10 @@ keys when IME input is received.  */);
   defsubr (&Sw32_request_user_attention);
   DEFSYM (Qinformational, "informational");
   DEFSYM (Qcritical, "critical");
+  /* System sleep support.  */
+  defsubr (&Sw32_unblock_system_sleep);
+  defsubr (&Sw32_block_system_sleep);
+  defsubr (&Sw32_system_sleep_block_count);
 #endif
 }
 
@@ -12094,6 +12228,7 @@ void
 globals_of_w32fns (void)
 {
   HMODULE user32_lib = GetModuleHandle ("user32.dll");
+  HMODULE kernel32_lib = GetModuleHandle ("kernel32.dll");
   /*
     TrackMouseEvent not available in all versions of Windows, so must load
     it dynamically.  Do it once, here, instead of every time it is used.
@@ -12120,6 +12255,16 @@ globals_of_w32fns (void)
   RegisterTouchWindow_fn
     = (RegisterTouchWindow_proc) get_proc_addr (user32_lib,
                                                 "RegisterTouchWindow");
+  /* For system sleep support.  */
+  SetThreadExecutionState_fn
+    = (SetThreadExecutionState_Proc)
+    get_proc_addr (kernel32_lib,
+                   "SetThreadExecutionState");
+  RegisterSuspendResumeNotification_fn
+    = (RegisterSuspendResumeNotification_Proc)
+    get_proc_addr (user32_lib,
+                   "RegisterSuspendResumeNotification");
+
   SetGestureConfig_fn
     = (SetGestureConfig_proc) get_proc_addr (user32_lib,
                                              "SetGestureConfig");
diff --git a/src/w32term.c b/src/w32term.c
index 091a1fbd5f1..5b7d9c5f17d 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -8249,6 +8249,7 @@ w32_initialize (void)
   }
 
   w32_get_mouse_wheel_vertical_delta ();
+  w32_register_for_sleep_notifications ();
 }
 
 void
diff --git a/src/w32term.h b/src/w32term.h
index 91db0b6e249..cb9d59371a4 100644
--- a/src/w32term.h
+++ b/src/w32term.h
@@ -274,6 +274,7 @@ extern const char *w32_get_string_resource (void *v_rdb,
 extern frame_parm_handler w32_frame_parm_handlers[];
 extern void w32_default_font_parameter (struct frame* f, Lisp_Object parms);
 extern Lisp_Object w32_process_dnd_data (int format, void *pDataObj);
+extern void w32_register_for_sleep_notifications();
 
 
 #define PIX_TYPE COLORREF