From 71b5c1d59118509c4679dcb1cdef8bb352ef6513 Mon Sep 17 00:00:00 2001 From: Guogang Li Date: Mon, 21 Aug 2023 14:10:49 -0700 Subject: [PATCH] Put some logs in session manager PiperOrigin-RevId: 558896551 --- .../implementation/windows/session_manager.cc | 131 +++++++++++------- .../implementation/windows/session_manager.h | 13 ++ 2 files changed, 94 insertions(+), 50 deletions(-) diff --git a/internal/platform/implementation/windows/session_manager.cc b/internal/platform/implementation/windows/session_manager.cc index 09c207b9..3624a3ae 100644 --- a/internal/platform/implementation/windows/session_manager.cc +++ b/internal/platform/implementation/windows/session_manager.cc @@ -18,8 +18,10 @@ #include #include +#include #include "absl/base/attributes.h" +#include "absl/base/const_init.h" #include "absl/container/flat_hash_map.h" #include "absl/functional/any_invocable.h" #include "absl/synchronization/mutex.h" @@ -34,36 +36,24 @@ namespace { constexpr char kMessageWindowClass[] = "Nearby Message Window Class"; constexpr char kMessageWindowTitle[] = "Nearby Message Dummy Window"; -// Define global static variables. -ABSL_CONST_INIT absl::Mutex kSessionMutex(absl::kConstInit); -HWND kSessionHwnd = nullptr; -SubmittableExecutor* kSessionThread = nullptr; -absl::flat_hash_map>* - kSessionCallbacks = nullptr; - LRESULT CALLBACK NearbyWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { switch (uMsg) { case WM_DESTROY: PostQuitMessage(0); - return 0; + break; case WM_WTSSESSION_CHANGE: if (wParam == WTS_SESSION_LOCK) { - absl::MutexLock lock(&kSessionMutex); - for (auto& it : *kSessionCallbacks) { - it.second(SessionManager::SessionState::kLock); - } + SessionManager::NotifySessionState(SessionManager::SessionState::kLock); } else if (wParam == WTS_SESSION_UNLOCK) { - absl::MutexLock lock(&kSessionMutex); - for (auto& it : *kSessionCallbacks) { - it.second(SessionManager::SessionState::kUnlock); - } + SessionManager::NotifySessionState( + SessionManager::SessionState::kUnlock); } - return 0; - default: - return DefWindowProc(hwnd, uMsg, wParam, lParam); + break; } + + // NOLINTNEXTLINE(misc-include-cleaner) + return DefWindowProc(hwnd, uMsg, wParam, lParam); } HWND CreateNearbyWindow() { @@ -87,58 +77,75 @@ HWND CreateNearbyWindow() { } // namespace +// Initialize class static variables. +ABSL_CONST_INIT absl::Mutex SessionManager::session_mutex_{absl::kConstInit}; +HWND SessionManager::session_hwnd_ = nullptr; +SubmittableExecutor* SessionManager::session_thread_ = nullptr; +absl::flat_hash_map>* + SessionManager::session_callbacks_ = nullptr; + SessionManager::~SessionManager() { StopSession(); } bool SessionManager::RegisterSessionListener( absl::string_view listener_name, absl::AnyInvocable callback) { - absl::MutexLock lock(&kSessionMutex); + absl::MutexLock lock(&session_mutex_); + NEARBY_LOGS(INFO) << __func__ << ": Registering listener: " << listener_name; // Create session thread if no running thread. - if (kSessionThread == nullptr) { + if (session_thread_ == nullptr) { absl::Notification notification; - kSessionThread = new SubmittableExecutor(); - kSessionCallbacks = new absl::flat_hash_map< + session_thread_ = new SubmittableExecutor(); + session_callbacks_ = new absl::flat_hash_map< std::string, absl::AnyInvocable>(); - kSessionThread->Execute( + session_thread_->Execute( [this, ¬ification]() { StartSession(notification); }); notification.WaitForNotification(); - if (kSessionThread == nullptr) { + if (session_thread_ == nullptr) { return false; } } - if (kSessionCallbacks->contains(listener_name) || + if (session_callbacks_->contains(listener_name) || listeners_.contains(listener_name)) { return false; } - kSessionCallbacks->emplace(listener_name, std::move(callback)); + session_callbacks_->emplace(listener_name, std::move(callback)); listeners_.emplace(listener_name); + NEARBY_LOGS(INFO) << __func__ << ": Session listener: " << listener_name + << " is registered."; return true; } bool SessionManager::UnregisterSessionListener( absl::string_view listener_name) { - absl::MutexLock lock(&kSessionMutex); - if (kSessionThread == nullptr) { + absl::MutexLock lock(&session_mutex_); + NEARBY_LOGS(INFO) << __func__ + << ": Unregistering listener: " << listener_name; + if (session_thread_ == nullptr) { NEARBY_LOGS(ERROR) << __func__ << ": No running listener."; return false; } - if (!kSessionCallbacks->contains(listener_name) || + if (!session_callbacks_->contains(listener_name) || !listeners_.contains(listener_name)) { NEARBY_LOGS(ERROR) << __func__ << ": No listener with name:" << listener_name; return false; } - kSessionCallbacks->erase(listener_name); + session_callbacks_->erase(listener_name); listeners_.erase(listener_name); - if (!kSessionCallbacks->empty()) { + if (!session_callbacks_->empty()) { + NEARBY_LOGS(INFO) << __func__ << ": Session listener: " << listener_name + << " is unregistered."; return true; } CleanUp(); + NEARBY_LOGS(INFO) << __func__ << ": Session listener: " << listener_name + << " is unregistered."; return true; } @@ -188,14 +195,30 @@ bool SessionManager::AllowSleep() const { return true; } +void SessionManager::NotifySessionState(SessionState state) { + NEARBY_LOGS(INFO) << __func__ + << ": Notifying session state: " << static_cast(state); + if (state == SessionManager::SessionState::kLock) { + absl::MutexLock lock(&session_mutex_); + for (auto& it : *SessionManager::session_callbacks_) { + it.second(SessionManager::SessionState::kLock); + } + } else if (state == SessionManager::SessionState::kUnlock) { + absl::MutexLock lock(&session_mutex_); + for (auto& it : *SessionManager::session_callbacks_) { + it.second(SessionManager::SessionState::kUnlock); + } + } +} + void SessionManager::StartSession(absl::Notification& notification) { - kSessionHwnd = CreateNearbyWindow(); - if (kSessionHwnd == nullptr) { + session_hwnd_ = CreateNearbyWindow(); + if (session_hwnd_ == nullptr) { NEARBY_LOGS(ERROR) << __func__ << ": Failed to create session Window."; return; } - if (!WTSRegisterSessionNotification(kSessionHwnd, NOTIFY_FOR_THIS_SESSION)) { + if (!WTSRegisterSessionNotification(session_hwnd_, NOTIFY_FOR_THIS_SESSION)) { NEARBY_LOGS(ERROR) << __func__ << ":Failed to register session notification."; return; @@ -203,14 +226,17 @@ void SessionManager::StartSession(absl::Notification& notification) { notification.Notify(); + NEARBY_LOGS(INFO) << __func__ << ": Session thread started."; + // Main message loop MSG msg = {}; - while (GetMessage(&msg, nullptr, 0, 0)) { + // NOLINTNEXTLINE(misc-include-cleaner) + while (GetMessage(&msg, session_hwnd_, 0, 0)) { TranslateMessage(&msg); DispatchMessage(&msg); } - if (!WTSUnRegisterSessionNotification(kSessionHwnd)) { + if (!WTSUnRegisterSessionNotification(session_hwnd_)) { NEARBY_LOGS(ERROR) << __func__ << ": Failed to register session notification."; return; @@ -225,16 +251,20 @@ void SessionManager::StartSession(absl::Notification& notification) { } void SessionManager::StopSession() { - absl::MutexLock lock(&kSessionMutex); - if (kSessionThread == nullptr) { + if (session_thread_ == nullptr) { + return; + } + + absl::MutexLock lock(&session_mutex_); + if (session_thread_ == nullptr) { return; } for (const auto& it : listeners_) { - kSessionCallbacks->erase(it); + session_callbacks_->erase(it); } listeners_.clear(); - if (!kSessionCallbacks->empty()) { + if (!session_callbacks_->empty()) { return; } @@ -242,17 +272,18 @@ void SessionManager::StopSession() { } void SessionManager::CleanUp() { - if (kSessionHwnd != nullptr) { + if (session_hwnd_ != nullptr) { // Send message to destroy message window. - PostMessageA(kSessionHwnd, WM_DESTROY, 0, 0); + // NOLINTNEXTLINE(misc-include-cleaner) + PostMessageA(session_hwnd_, WM_DESTROY, 0, 0); } - kSessionThread->Shutdown(); - delete kSessionThread; - delete kSessionCallbacks; - kSessionThread = nullptr; - kSessionCallbacks = nullptr; - kSessionHwnd = nullptr; + session_thread_->Shutdown(); + delete session_thread_; + delete session_callbacks_; + session_thread_ = nullptr; + session_callbacks_ = nullptr; + session_hwnd_ = nullptr; } } // namespace windows diff --git a/internal/platform/implementation/windows/session_manager.h b/internal/platform/implementation/windows/session_manager.h index a5da2c26..e3faf4b8 100644 --- a/internal/platform/implementation/windows/session_manager.h +++ b/internal/platform/implementation/windows/session_manager.h @@ -17,10 +17,13 @@ #include +#include "absl/container/flat_hash_map.h" #include "absl/container/flat_hash_set.h" #include "absl/functional/any_invocable.h" #include "absl/strings/string_view.h" +#include "absl/synchronization/mutex.h" #include "absl/synchronization/notification.h" +#include "internal/platform/implementation/windows/submittable_executor.h" namespace nearby { namespace windows { @@ -49,12 +52,22 @@ class SessionManager { // Allows the Windows device to sleep state. bool AllowSleep() const; + static void NotifySessionState(SessionState state); + private: void StartSession(absl::Notification& notification); void StopSession(); void CleanUp(); absl::flat_hash_set listeners_; + + // Static class members + static absl::Mutex session_mutex_; + static HWND session_hwnd_; + static SubmittableExecutor* session_thread_; + static absl::flat_hash_map< + std::string, absl::AnyInvocable>* + session_callbacks_; }; } // namespace windows