Can Application register when PC goes into sleep/hibernate mode or when it resumes

[byrialsen]

Hi

Is it possible to have an MSIX packaged WindowsAppSDK application to do some task either when the PC goes into sleep/hibernate mode or maybe when it returns/resume from sleep/hibernate mode. Something similar to .Net code like

Microsoft.Win32.SystemEvents.SessionSwitch += new Microsoft.Win32.SessionSwitchEventHandler(OnSessionSwitch);
       
private void OnSessionSwitch(object sender, SessionSwitchEventArgs e)
{
  // do the magic
}

I need it to run some simple "killtask" command either when the pc goes into sleep/hibernate mode or returns.

[castorix]

You can intercept WM_POWERBROADCAST, with SetWindowSubclass
(tested on Windows 10 21H1)

[byrialsen]

Sounds promising but not sure I know how to implement that. Do you have any link for source code that gives me the basic idea of how to do it from my app.

[castorix]

For example :
(you can add tests of wParam (PBT_APMSUSPEND, ...))

        public delegate int SUBCLASSPROC(IntPtr hWnd, uint uMsg, IntPtr wParam, IntPtr lParam, IntPtr uIdSubclass, uint dwRefData);

        [DllImport("Comctl32.dll", SetLastError = true)]
        public static extern bool SetWindowSubclass(IntPtr hWnd, SUBCLASSPROC pfnSubclass, uint uIdSubclass, uint dwRefData);

        [DllImport("Comctl32.dll", SetLastError = true)]
        public static extern int DefSubclassProc(IntPtr hWnd, uint uMsg, IntPtr wParam, IntPtr lParam);
        
        public const int WM_POWERBROADCAST = 0x0218;

        public const int PBT_APMQUERYSUSPEND = 0x0000;
        public const int PBT_APMQUERYSTANDBY = 0x0001;
        public const int PBT_APMQUERYSUSPENDFAILED = 0x0002;
        public const int PBT_APMQUERYSTANDBYFAILED = 0x0003;
        public const int PBT_APMSUSPEND = 0x0004;
        public const int PBT_APMSTANDBY = 0x0005;
        public const int PBT_APMRESUMECRITICAL = 0x0006;
        public const int PBT_APMRESUMESUSPEND = 0x0007;
        public const int PBT_APMRESUMESTANDBY = 0x0008;
        public const int PBTF_APMRESUMEFROMFAILURE = 0x00000001;
        public const int PBT_APMBATTERYLOW = 0x0009;
        public const int PBT_APMPOWERSTATUSCHANGE = 0x000A;
        public const int PBT_APMOEMEVENT = 0x000B;
        public const int PBT_APMRESUMEAUTOMATIC = 0x0012;
        public const int PBT_POWERSETTINGCHANGE = 0x8013;
        
        IntPtr hWnd = IntPtr.Zero;
        private SUBCLASSPROC SubClassDelegate;
        
        public MainWindow()
        {
            this.InitializeComponent();

            hWnd = WinRT.Interop.WindowNative.GetWindowHandle(this);
            SubClassDelegate = new SUBCLASSPROC(WindowSubClass);
            bool bRet = SetWindowSubclass(hWnd, SubClassDelegate, 0, 0);
        }
        
        private int WindowSubClass(IntPtr hWnd, uint uMsg, IntPtr wParam, IntPtr lParam, IntPtr uIdSubclass, uint dwRefData)
        {
            switch (uMsg)
            {               
                case WM_POWERBROADCAST:
                    {
                        System.Diagnostics.Debug.WriteLine(string.Format("WM_POWERBROADCAST - wParam = 0x{0:X4}", wParam));                           
                        Console.Beep(1000, 100);
                    }
                    break;              
            }
            return DefSubclassProc(hWnd, uMsg, wParam, lParam);
        }   

[byrialsen]

@castorix. The code seems to work very nice. BUT the problem is that I am not getting the WM_POWERBROADCAST eventhough I hibernate my PC.

Testing with display settings changed instead works like a charm

public const int WM_DISPLAYCHANGE = 0x007E;

Any clues?

[castorix]

On my PC, I get 0x0004 then 0x0007, 0x0012

Maybe you can register notifications, for example with PowerRegisterSuspendResumeNotification

A quick test :

            DEVICE_NOTIFY_SUBSCRIBE_PARAMETERS dnsp = new DEVICE_NOTIFY_SUBSCRIBE_PARAMETERS();
            dnsp.Callback = new DEVICE_NOTIFY_CALLBACK_ROUTINE(DeviceNotifyCallbackRoutine);

            IntPtr pDeviceNotify = Marshal.AllocHGlobal(Marshal.SizeOf(dnsp));
            Marshal.StructureToPtr(dnsp, pDeviceNotify, false);
            IntPtr pRegistrationHandle = IntPtr.Zero;
            uint nRet = PowerRegisterSuspendResumeNotification(DEVICE_NOTIFY_CALLBACK, pDeviceNotify, out pRegistrationHandle);
            Marshal.FreeHGlobal(pDeviceNotify);

Callback :

        private static uint DeviceNotifyCallbackRoutine(IntPtr Context, uint Type, IntPtr Setting)
        {           
            Console.Beep(1000, 100);
            //  PBT_APMSUSPEND, PBT_APMRESUMESUSPEND, PBT_APMRESUMEAUTOMATIC
            System.Diagnostics.Debug.WriteLine(string.Format("DeviceNotify - Type = 0x{0:X4}", Type));          
            return 0;
        }

Declarations :

       [DllImport("Powrprof.dll", SetLastError = true, CharSet = CharSet.Unicode)]
       public static extern uint PowerRegisterSuspendResumeNotification(uint Flags, IntPtr Recipient, out IntPtr RegistrationHandle);

       [StructLayout(LayoutKind.Sequential)]
       public struct DEVICE_NOTIFY_SUBSCRIBE_PARAMETERS
       {
           public DEVICE_NOTIFY_CALLBACK_ROUTINE Callback;
           public IntPtr Context;
       }

       public delegate uint DEVICE_NOTIFY_CALLBACK_ROUTINE(IntPtr Context, uint Type, IntPtr Setting);

       public const int DEVICE_NOTIFY_CALLBACK = 2; 

[byrialsen]

@castorix. I have testet the solution on a couple of devices now and the last solution is perfect. Thanks a lot for helping me out. I really appreciate it. 🙏💪

[alski]

Hmmm... copied the above code extract into an existing WinUI3 app and I just get process exited code 0 during sleep/resume.
Tried a few things, but no joy.

Had success with microsoft/microsoft-ui-xaml#5139
AppSDK 1.5.240311000