widget/windows/WinEventObserver.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include <windows.h>
   8 #include <winuser.h>
   9 #include <wtsapi32.h>
  10
  11 #include "WinEventObserver.h"
  12
  13 #include "mozilla/ClearOnShutdown.h"
  14 #include "mozilla/Logging.h"
  15 #include "mozilla/StaticPtr.h"
  16 #include "nsHashtablesFwd.h"
  17 #include "nsdefs.h"
  18
  19 namespace mozilla::widget {
  20
  21 LazyLogModule gWinEventObserverLog("WinEventObserver");
  22 #define LOG(...) MOZ_LOG(gWinEventObserverLog, LogLevel::Info, (__VA_ARGS__))
  23
  24 // static
  25 StaticRefPtr<WinEventHub> WinEventHub::sInstance;
  26
  27 // static
  28 bool WinEventHub::Ensure() {
  29   if (sInstance) {
  30     return true;
  31   }
  32
  33   LOG("WinEventHub::Ensure()");
  34
  35   RefPtr<WinEventHub> instance = new WinEventHub();
  36   if (!instance->Initialize()) {
  37     MOZ_ASSERT_UNREACHABLE("unexpected to be called");
  38     return false;
  39   }
  40   sInstance = instance;
  41   ClearOnShutdown(&sInstance);
  42   return true;
  43 }
  44
  45 WinEventHub::WinEventHub() {
  46   MOZ_ASSERT(NS_IsMainThread());
  47   LOG("WinEventHub::WinEventHub()");
  48 }
  49
  50 WinEventHub::~WinEventHub() {
  51   MOZ_ASSERT(NS_IsMainThread());
  52   MOZ_ASSERT(mObservers.IsEmpty());
  53   LOG("WinEventHub::~WinEventHub()");
  54
  55   if (mHWnd) {
  56     ::DestroyWindow(mHWnd);
  57     mHWnd = nullptr;
  58   }
  59 }
  60
  61 bool WinEventHub::Initialize() {
  62   WNDCLASSW wc;
  63   HMODULE hSelf = ::GetModuleHandle(nullptr);
  64
  65   if (!GetClassInfoW(hSelf, L"MozillaWinEventHubClass", &wc)) {
  66     ZeroMemory(&wc, sizeof(WNDCLASSW));
  67     wc.hInstance = hSelf;
  68     wc.lpfnWndProc = WinEventProc;
  69     wc.lpszClassName = L"MozillaWinEventHubClass";
  70     RegisterClassW(&wc);
  71   }
  72
  73   mHWnd = ::CreateWindowW(L"MozillaWinEventHubClass", L"WinEventHub", 0, 0, 0,
  74                           0, 0, nullptr, nullptr, hSelf, nullptr);
  75   if (!mHWnd) {
  76     return false;
  77   }
  78
  79   return true;
  80 }
  81
  82 // static
  83 LRESULT CALLBACK WinEventHub::WinEventProc(HWND aHwnd, UINT aMsg,
  84                                            WPARAM aWParam, LPARAM aLParam) {
  85   if (sInstance) {
  86     sInstance->ProcessWinEventProc(aHwnd, aMsg, aWParam, aLParam);
  87   }
  88   return ::DefWindowProc(aHwnd, aMsg, aWParam, aLParam);
  89 }
  90
  91 void WinEventHub::ProcessWinEventProc(HWND aHwnd, UINT aMsg, WPARAM aWParam,
  92                                       LPARAM aLParam) {
  93   for (const auto& observer : mObservers) {
  94     observer->OnWinEventProc(aHwnd, aMsg, aWParam, aLParam);
  95   }
  96 }
  97
  98 void WinEventHub::AddObserver(WinEventObserver* aObserver) {
  99   LOG("WinEventHub::AddObserver() aObserver %p", aObserver);
 100
 101   mObservers.Insert(aObserver);
 102 }
 103
 104 void WinEventHub::RemoveObserver(WinEventObserver* aObserver) {
 105   LOG("WinEventHub::RemoveObserver() aObserver %p", aObserver);
 106
 107   mObservers.Remove(aObserver);
 108 }
 109
 110 WinEventObserver::~WinEventObserver() {
 111   MOZ_ASSERT(NS_IsMainThread());
 112   MOZ_ASSERT(mDestroyed);
 113 }
 114
 115 void WinEventObserver::Destroy() {
 116   LOG("WinEventObserver::Destroy() this %p", this);
 117
 118   WinEventHub::Get()->RemoveObserver(this);
 119   mDestroyed = true;
 120 }
 121
 122 // static
 123 already_AddRefed<DisplayStatusObserver> DisplayStatusObserver::Create(
 124     DisplayStatusListener* aListener) {
 125   if (!WinEventHub::Ensure()) {
 126     return nullptr;
 127   }
 128   RefPtr<DisplayStatusObserver> observer = new DisplayStatusObserver(aListener);
 129   WinEventHub::Get()->AddObserver(observer);
 130   return observer.forget();
 131 }
 132
 133 DisplayStatusObserver::DisplayStatusObserver(DisplayStatusListener* aListener)
 134     : mListener(aListener) {
 135   MOZ_ASSERT(NS_IsMainThread());
 136   LOG("DisplayStatusObserver::DisplayStatusObserver() this %p", this);
 137
 138   mDisplayStatusHandle = ::RegisterPowerSettingNotification(
 139       WinEventHub::Get()->GetWnd(), &GUID_SESSION_DISPLAY_STATUS,
 140       DEVICE_NOTIFY_WINDOW_HANDLE);
 141 }
 142
 143 DisplayStatusObserver::~DisplayStatusObserver() {
 144   MOZ_ASSERT(NS_IsMainThread());
 145   LOG("DisplayStatusObserver::~DisplayStatusObserver() this %p", this);
 146
 147   if (mDisplayStatusHandle) {
 148     ::UnregisterPowerSettingNotification(mDisplayStatusHandle);
 149     mDisplayStatusHandle = nullptr;
 150   }
 151 }
 152
 153 void DisplayStatusObserver::OnWinEventProc(HWND aHwnd, UINT aMsg,
 154                                            WPARAM aWParam, LPARAM aLParam) {
 155   if (aMsg == WM_POWERBROADCAST && aWParam == PBT_POWERSETTINGCHANGE) {
 156     POWERBROADCAST_SETTING* setting = (POWERBROADCAST_SETTING*)aLParam;
 157     if (setting &&
 158         ::IsEqualGUID(setting->PowerSetting, GUID_SESSION_DISPLAY_STATUS) &&
 159         setting->DataLength == sizeof(DWORD)) {
 160       bool displayOn = PowerMonitorOff !=
 161                        static_cast<MONITOR_DISPLAY_STATE>(setting->Data[0]);
 162
 163       LOG("DisplayStatusObserver::OnWinEventProc() displayOn %d this %p",
 164           displayOn, this);
 165       mListener->OnDisplayStateChanged(displayOn);
 166     }
 167   }
 168 }
 169
 170 // static
 171 already_AddRefed<SessionChangeObserver> SessionChangeObserver::Create(
 172     SessionChangeListener* aListener) {
 173   if (!WinEventHub::Ensure()) {
 174     return nullptr;
 175   }
 176   RefPtr<SessionChangeObserver> observer = new SessionChangeObserver(aListener);
 177   WinEventHub::Get()->AddObserver(observer);
 178   return observer.forget();
 179 }
 180
 181 SessionChangeObserver::SessionChangeObserver(SessionChangeListener* aListener)
 182     : mListener(aListener) {
 183   MOZ_ASSERT(NS_IsMainThread());
 184   LOG("SessionChangeObserver::SessionChangeObserver() this %p", this);
 185
 186   auto hwnd = WinEventHub::Get()->GetWnd();
 187   DebugOnly<BOOL> wtsRegistered =
 188       ::WTSRegisterSessionNotification(hwnd, NOTIFY_FOR_THIS_SESSION);
 189   NS_ASSERTION(wtsRegistered, "WTSRegisterSessionNotification failed!\n");
 190 }
 191 SessionChangeObserver::~SessionChangeObserver() {
 192   MOZ_ASSERT(NS_IsMainThread());
 193   LOG("SessionChangeObserver::~SessionChangeObserver() this %p", this);
 194
 195   auto hwnd = WinEventHub::Get()->GetWnd();
 196   // Unregister notifications from terminal services
 197   ::WTSUnRegisterSessionNotification(hwnd);
 198 }
 199
 200 void SessionChangeObserver::OnWinEventProc(HWND aHwnd, UINT aMsg,
 201                                            WPARAM aWParam, LPARAM aLParam) {
 202   if (aMsg == WM_WTSSESSION_CHANGE &&
 203       (aWParam == WTS_SESSION_LOCK || aWParam == WTS_SESSION_UNLOCK)) {
 204     Maybe<bool> isCurrentSession;
 205     DWORD currentSessionId = 0;
 206     if (!::ProcessIdToSessionId(::GetCurrentProcessId(), &currentSessionId)) {
 207       isCurrentSession = Nothing();
 208     } else {
 209       LOG("SessionChangeObserver::OnWinEventProc() aWParam %zu aLParam "
 210           "%" PRIdLPTR
 211           " "
 212           "currentSessionId %lu this %p",
 213           aWParam, aLParam, currentSessionId, this);
 214
 215       isCurrentSession = Some(static_cast<DWORD>(aLParam) == currentSessionId);
 216     }
 217     mListener->OnSessionChange(aWParam, isCurrentSession);
 218   }
 219 }
 220
 221 #undef LOG
 222
 223 }  // namespace mozilla::widget