Add wake_sleep functionality to Windows

Author: streetpea

gui/CMakeLists.txt

@@ -77,6 +77,11 @@ if(APPLE)
 		include/macWakeSleep.h
 		src/macWakeSleep.cpp
 	)
+elseif(WIN32)
+	list(APPEND SOURCE_FILES
+		include/windowsWakeSleep.h
+		src/windowsWakeSleep.cpp
+	)
 endif()
 
 add_executable(chiaki WIN32

gui/include/qmlbackend.h

@@ -20,6 +20,8 @@
 class SystemdInhibit;
 #ifdef Q_OS_MACOS
     class MacWakeSleep;
+#elif defined(Q_OS_WINDOWS)
+    class WindowsWakeSleep;
 #endif
 
 class QmlRegist : public QObject
@@ -290,6 +292,8 @@ class QmlBackend : public QObject
     SystemdInhibit *sleep_inhibit = {};
 #ifdef Q_OS_MACOS
     MacWakeSleep *mac_wake_sleep = {};
+#elif defined(Q_OS_WINDOWS)
+    WindowsWakeSleep *windows_wake_sleep = {};
 #endif
     bool controller_mapping_default_mapping = false;
     bool controller_mapping_altered = false;

gui/include/windowsWakeSleep.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <QObject>
+#include <windows.h>
+
+typedef enum windows_wake_state_t {
+    Awake = 0,
+    AboutToSleep = 1,
+    Sleeping = 2
+} WindowsWakeState;
+
+class WindowsWakeSleep : public QObject
+{
+	Q_OBJECT
+
+public:
+    WindowsWakeSleep(QObject *parent = nullptr);
+    ~WindowsWakeSleep();
+    void awake();
+    void aboutToSleep();
+    WindowsWakeState getWakeState();
+    void setWakeState(WindowsWakeState state);
+
+signals:
+    void wokeUp();
+    void sleeping();
+
+private:
+    HPOWERNOTIFY hPowerNotify = {};
+    WindowsWakeState wake_state = WindowsWakeState::Awake;
+};

gui/src/qml/qtwebengine_import.qml

@@ -9,6 +9,8 @@
 #include "chiaki/remote/holepunch.h"
 #ifdef Q_OS_MACOS
 #include "macWakeSleep.h"
+#elif defined(Q_OS_WINDOWS)
+#include "windowsWakeSleep.h"
 #endif
 #if CHIAKI_GUI_ENABLE_STEAM_SHORTCUT
 #include "steamtools.h"
@@ -227,6 +229,10 @@ QmlBackend::QmlBackend(Settings *settings, QmlMainWindow *window)
     mac_wake_sleep = new MacWakeSleep(this);
     connect(mac_wake_sleep, &MacWakeSleep::wokeUp, this, &QmlBackend::resumeFromSleep);
     connect(ControllerManager::GetInstance(), &ControllerManager::ControllerMoved, mac_wake_sleep, &MacWakeSleep::simulateUserActivity);
+#elif defined(Q_OS_WINDOWS)
+    windows_wake_sleep = new WindowsWakeSleep(this);
+    connect(windows_wake_sleep, &WindowsWakeSleep::wokeUp, this, &QmlBackend::resumeFromSleep);
+    connect(windows_wake_sleep, &WindowsWakeSleep::sleeping, this, &QmlBackend::goToSleep);
 #endif
     refreshPsnToken();
 }
@@ -287,7 +293,14 @@ void QmlBackend::goToSleep()
 }
 void QmlBackend::resumeFromSleep()
 {
-    qCInfo(chiakiGui) << "Resumed from sleep";
+#ifdef Q_OS_WINDOWS
+    if(windows_wake_sleep->getWakeState() == WindowsWakeState::AboutToSleep)
+    {
+        windows_wake_sleep->setWakeState(WindowsWakeState::Awake);
+        return;
+    }
+    windows_wake_sleep->setWakeState(WindowsWakeState::Awake);
+#endif
     if (resume_session) {
         qCInfo(chiakiGui) << "Resuming session...";
         resume_session = false;
@@ -418,6 +431,11 @@ void QmlBackend::profileChanged()
     mac_wake_sleep = new MacWakeSleep(this);
     connect(mac_wake_sleep, &MacWakeSleep::wokeUp, this, &QmlBackend::resumeFromSleep);
     connect(ControllerManager::GetInstance(), &ControllerManager::ControllerMoved, mac_wake_sleep, &MacWakeSleep::simulateUserActivity);
+#elif defined(Q_OS_WINDOWS)
+    windows_wake_sleep->deleteLater();
+    windows_wake_sleep = new WindowsWakeSleep(this);
+    connect(windows_wake_sleep, &WindowsWakeSleep::wokeUp, this, &QmlBackend::resumeFromSleep);
+    connect(windows_wake_sleep, &WindowsWakeSleep::sleeping, this, &QmlBackend::goToSleep);
 #endif
     refreshPsnToken();
     emit hostsChanged();
@@ -791,6 +809,13 @@ void QmlBackend::createSession(const StreamSessionConnectInfo &connect_info)
 
         sleep_inhibit->release();
         setDiscoveryEnabled(true);
+#ifdef Q_OS_WINDOWS
+        qCInfo(chiakiGui) << "Checking sleep state: ";
+        if(windows_wake_sleep->getWakeState() == WindowsWakeState::Awake)
+            QTimer::singleShot(2000, this, &QmlBackend::resumeFromSleep);
+        else
+            windows_wake_sleep->setWakeState(WindowsWakeState::Sleeping);
+#endif
     });
 
     connect(session, &StreamSession::LoginPINRequested, this, [this, connect_info](bool incorrect) {

gui/src/qmlbackend.cpp

@@ -0,0 +1,104 @@
+#include "windowsWakeSleep.h"
+#include "qmlmainwindow.h"
+extern "C" {
+#include <powrprof.h>
+}
+#pragma comment(lib, "powrprof.lib")
+
+static ULONG MySleepCallBack(PVOID windowsWakeSleep, ULONG messageType, PVOID Setting)
+{
+    
+    WindowsWakeSleep *windows_wake_sleep = reinterpret_cast<WindowsWakeSleep *>(windowsWakeSleep);
+    switch (messageType)
+    {
+        case PBT_APMSUSPEND:
+            /* System is suspending
+                Perform needed actions before system goes to sleep
+            */
+            windows_wake_sleep->aboutToSleep();
+
+        case PBT_APMRESUMESUSPEND:
+
+            /* System is resuming from suspend
+                Perform needed action after waking up
+            */
+            windows_wake_sleep->awake();
+            break;
+
+        case PBT_APMRESUMEAUTOMATIC:
+
+            /* System is resuming automatically (i.e., scheduled wake-up)
+                Perform needed action after waking up
+            */
+            windows_wake_sleep->awake();
+            break; 
+
+        default:
+
+            break;
+    }
+    return 0;
+}
+
+WindowsWakeSleep::WindowsWakeSleep(QObject *parent)
+    : QObject(parent)
+    , wake_state(WindowsWakeState::Awake)
+{
+#ifndef DEVICE_NOTIFY_CALLBACK
+#define DEVICE_NOTIFY_CALLBACK 2
+#endif
+#ifndef DEVICE_NOTIFY_CALLBACK_ROUTINE
+    typedef
+    ULONG
+    CALLBACK
+    DEVICE_NOTIFY_CALLBACK_ROUTINE (
+        _In_opt_ PVOID Context,
+        _In_ ULONG Type,
+        _In_ PVOID Setting
+        );
+    typedef DEVICE_NOTIFY_CALLBACK_ROUTINE* PDEVICE_NOTIFY_CALLBACK_ROUTINE;
+#endif
+#ifndef _DEVICE_NOTIFY_SUBSCRIBE_PARAMETERS
+    typedef struct _DEVICE_NOTIFY_SUBSCRIBE_PARAMETERS {
+        PDEVICE_NOTIFY_CALLBACK_ROUTINE Callback;
+        PVOID Context;
+    } DEVICE_NOTIFY_SUBSCRIBE_PARAMETERS, *PDEVICE_NOTIFY_SUBSCRIBE_PARAMETERS;
+#endif
+    static DEVICE_NOTIFY_SUBSCRIBE_PARAMETERS sleepCallback = {
+        MySleepCallBack,
+        this
+    };
+    // register to receive system sleep notifications
+    hPowerNotify = RegisterSuspendResumeNotification(&sleepCallback, DEVICE_NOTIFY_CALLBACK);
+    if (hPowerNotify == NULL)
+    {
+        qCCritical(chiakiGui) << "Failed to register for system sleep notifications with error:" << GetLastError();
+    }
+}
+
+WindowsWakeSleep::~WindowsWakeSleep()
+{
+    // unregister for system sleep notifications
+    UnregisterSuspendResumeNotification(hPowerNotify);
+}
+
+void WindowsWakeSleep::setWakeState(WindowsWakeState state)
+{
+    this->wake_state = state;
+}
+
+WindowsWakeState WindowsWakeSleep::getWakeState()
+{
+    return this->wake_state;
+}
+
+void WindowsWakeSleep::awake()
+{
+    emit wokeUp();
+}
+
+void WindowsWakeSleep::aboutToSleep()
+{
+    setWakeState(WindowsWakeState::AboutToSleep);
+    emit sleeping();
+}

gui/src/windowsWakeSleep.cpp

@@ -46,7 +46,7 @@ CHIAKI_EXPORT ChiakiErrorCode chiaki_stop_pipe_select_single(ChiakiStopPipe *sto
 /**
  * Like connect(), but can be canceled by the stop pipe. Only makes sense with a non-blocking socket.
  */
-CHIAKI_EXPORT ChiakiErrorCode chiaki_stop_pipe_connect(ChiakiStopPipe *stop_pipe, chiaki_socket_t fd, struct sockaddr *addr, size_t addrlen);
+CHIAKI_EXPORT ChiakiErrorCode chiaki_stop_pipe_connect(ChiakiStopPipe *stop_pipe, chiaki_socket_t fd, struct sockaddr *addr, size_t addrlen, uint64_t timeout_ms);
 static inline ChiakiErrorCode chiaki_stop_pipe_sleep(ChiakiStopPipe *stop_pipe, uint64_t timeout_ms) { return chiaki_stop_pipe_select_single(stop_pipe, CHIAKI_INVALID_SOCKET, false, timeout_ms); }
 CHIAKI_EXPORT ChiakiErrorCode chiaki_stop_pipe_reset(ChiakiStopPipe *stop_pipe);
 

lib/include/chiaki/stoppipe.h

@@ -1110,7 +1110,7 @@ static ChiakiErrorCode ctrl_connect(ChiakiCtrl *ctrl)
 			CHIAKI_LOGE(session->log, "Failed to set ctrl socket to non-blocking: %s", chiaki_error_string(err));
 
 		chiaki_mutex_unlock(&ctrl->notif_mutex);
-		err = chiaki_stop_pipe_connect(&ctrl->notif_pipe, sock, sa, addr->ai_addrlen);
+		err = chiaki_stop_pipe_connect(&ctrl->notif_pipe, sock, sa, addr->ai_addrlen, 5000);
 		chiaki_mutex_lock(&ctrl->notif_mutex);
 		free(sa);
 		if(err != CHIAKI_ERR_SUCCESS)

lib/src/ctrl.c

@@ -824,7 +824,7 @@ static ChiakiErrorCode session_thread_request_session(ChiakiSession *session, Ch
 				CHIAKI_LOGE(session->log, "Failed to set session socket to non-blocking: %s", chiaki_error_string(err));
 
 			chiaki_mutex_unlock(&session->state_mutex);
-			err = chiaki_stop_pipe_connect(&session->stop_pipe, session_sock, sa, ai->ai_addrlen);
+			err = chiaki_stop_pipe_connect(&session->stop_pipe, session_sock, sa, ai->ai_addrlen, 5000);
 			chiaki_mutex_lock(&session->state_mutex);
 			if(err == CHIAKI_ERR_CANCELED)
 			{

lib/src/session.c

@@ -170,15 +170,15 @@ CHIAKI_EXPORT ChiakiErrorCode chiaki_stop_pipe_select_single(ChiakiStopPipe *sto
 #endif
 }
 
-CHIAKI_EXPORT ChiakiErrorCode chiaki_stop_pipe_connect(ChiakiStopPipe *stop_pipe, chiaki_socket_t fd, struct sockaddr *addr, size_t addrlen)
+CHIAKI_EXPORT ChiakiErrorCode chiaki_stop_pipe_connect(ChiakiStopPipe *stop_pipe, chiaki_socket_t fd, struct sockaddr *addr, size_t addrlen, uint64_t timeout_ms)
 {
 	int r = connect(fd, addr, (socklen_t)addrlen);
 	if(r >= 0)
 		return CHIAKI_ERR_SUCCESS;
 
 	if(CHIAKI_SOCKET_EINPROGRESS)
 	{
-		ChiakiErrorCode err = chiaki_stop_pipe_select_single(stop_pipe, fd, true, UINT64_MAX);
+		ChiakiErrorCode err = chiaki_stop_pipe_select_single(stop_pipe, fd, true, timeout_ms);
 		if(err != CHIAKI_ERR_SUCCESS)
 			return err;
 	}