flutter::WindowsLifecycleManager Class Reference

#include <windows_lifecycle_manager.h>

Inheritance diagram for flutter::WindowsLifecycleManager:

Public Member Functions
	WindowsLifecycleManager (FlutterWindowsEngine *engine)
virtual	~WindowsLifecycleManager ()
virtual void	Quit (std::optional< HWND > window, std::optional< WPARAM > wparam, std::optional< LPARAM > lparam, UINT exit_code)
bool	WindowProc (HWND hwnd, UINT msg, WPARAM w, LPARAM l, LRESULT *result)
virtual void	BeginProcessingLifecycle ()
virtual void	BeginProcessingExit ()
virtual void	SetLifecycleState (AppLifecycleState state)
virtual void	OnWindowStateEvent (HWND hwnd, WindowStateEvent event)
AppLifecycleState	GetLifecycleState ()
std::optional< LRESULT >	ExternalWindowMessage (HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)

Protected Member Functions
virtual bool	IsLastWindowOfProcess ()
virtual void	DispatchMessage (HWND window, UINT msg, WPARAM wparam, LPARAM lparam)

Detailed Description

A manager for lifecycle events of the top-level windows.

WndProc is called for window messages of the top-level Flutter window. ExternalWindowMessage is called for non-flutter top-level window messages. OnWindowStateEvent is called when the visibility or focus state of a window is changed, including the FlutterView window.

Definition at line 37 of file windows_lifecycle_manager.h.

Constructor & Destructor Documentation

WindowsLifecycleManager()

flutter::WindowsLifecycleManager::WindowsLifecycleManager

(

FlutterWindowsEngine *

engine

)

Definition at line 16 of file windows_lifecycle_manager.cc.

    : engine_(engine) {}

~WindowsLifecycleManager()

flutter::WindowsLifecycleManager::~WindowsLifecycleManager ( )

virtual

Definition at line 19 of file windows_lifecycle_manager.cc.

{}

Member Function Documentation

BeginProcessingExit()

void flutter::WindowsLifecycleManager::BeginProcessingExit ( )

virtual

Definition at line 191 of file windows_lifecycle_manager.cc.

                                                  {
  process_exit_ = true;
}

BeginProcessingLifecycle()

void flutter::WindowsLifecycleManager::BeginProcessingLifecycle ( )

virtual

Reimplemented in flutter::testing::MockWindowsLifecycleManager.

Definition at line 187 of file windows_lifecycle_manager.cc.

                                                       {
  process_lifecycle_ = true;
}

DispatchMessage()

void flutter::WindowsLifecycleManager::DispatchMessage ( HWND  window, UINT  msg, WPARAM  wparam, LPARAM  lparam  )

protectedvirtual

Definition at line 34 of file windows_lifecycle_manager.cc.

                                                             {
  PostMessage(hwnd, message, wparam, lparam);
}

ExternalWindowMessage()

std::optional< LRESULT > flutter::WindowsLifecycleManager::ExternalWindowMessage	(	HWND	hwnd,
		UINT	message,
		WPARAM	wparam,
		LPARAM	lparam
	)

Definition at line 256 of file windows_lifecycle_manager.cc.

                   {
  std::optional<flutter::WindowStateEvent> event = std::nullopt;
 
  // TODO (schectman): Handle WM_CLOSE messages.
  // https://github.com/flutter/flutter/issues/131497
  switch (message) {
    case WM_SHOWWINDOW:
      event = wparam ? flutter::WindowStateEvent::kShow
                     : flutter::WindowStateEvent::kHide;
      break;
    case WM_SIZE:
      switch (wparam) {
        case SIZE_MINIMIZED:
          event = flutter::WindowStateEvent::kHide;
          break;
        case SIZE_RESTORED:
        case SIZE_MAXIMIZED:
          event = flutter::WindowStateEvent::kShow;
          break;
      }
      break;
    case WM_SETFOCUS:
      event = flutter::WindowStateEvent::kFocus;
      break;
    case WM_KILLFOCUS:
      event = flutter::WindowStateEvent::kUnfocus;
      break;
    case WM_DESTROY:
      event = flutter::WindowStateEvent::kHide;
      break;
    case WM_CLOSE:
      if (HandleCloseMessage(hwnd, wparam, lparam)) {
        return NULL;
      }
      break;
  }
 
  if (event.has_value()) {
    OnWindowStateEvent(hwnd, *event);
  }
 
  return std::nullopt;
}

GetLifecycleState()

AppLifecycleState flutter::WindowsLifecycleManager::GetLifecycleState ( )

inline

Definition at line 75 of file windows_lifecycle_manager.h.

{ return state_; }

IsLastWindowOfProcess()

bool flutter::WindowsLifecycleManager::IsLastWindowOfProcess ( )

protectedvirtual

Definition at line 164 of file windows_lifecycle_manager.cc.

                                                    {
  DWORD pid = ::GetCurrentProcessId();
  ThreadSnapshot thread_snapshot;
  std::optional<THREADENTRY32> first_thread = thread_snapshot.GetFirstThread();
  if (!first_thread.has_value()) {
    FML_LOG(ERROR) << "No first thread found";
    return true;
  }
 
  int num_windows = 0;
  THREADENTRY32 thread = *first_thread;
  do {
    if (thread.th32OwnerProcessID == pid) {
      num_windows += NumWindowsForThread(thread);
      if (num_windows > 1) {
        return false;
      }
    }
  } while (thread_snapshot.GetNextThread(thread));
 
  return num_windows <= 1;
}

OnWindowStateEvent()

void flutter::WindowsLifecycleManager::OnWindowStateEvent ( HWND  hwnd, WindowStateEvent  event  )

virtual

Definition at line 208 of file windows_lifecycle_manager.cc.

                                                                         {
  // Synthesize an unfocus event when a focused window is hidden.
  if (event == WindowStateEvent::kHide &&
      focused_windows_.find(hwnd) != focused_windows_.end()) {
    OnWindowStateEvent(hwnd, WindowStateEvent::kUnfocus);
  }
 
  std::lock_guard guard(state_update_lock_);
  switch (event) {
    case WindowStateEvent::kShow: {
      bool first_shown_window = visible_windows_.empty();
      auto pair = visible_windows_.insert(hwnd);
      if (first_shown_window && pair.second &&
          state_ == AppLifecycleState::kHidden) {
        SetLifecycleState(AppLifecycleState::kInactive);
      }
      break;
    }
    case WindowStateEvent::kHide: {
      bool present = visible_windows_.erase(hwnd);
      bool empty = visible_windows_.empty();
      if (present && empty &&
          (state_ == AppLifecycleState::kResumed ||
           state_ == AppLifecycleState::kInactive)) {
        SetLifecycleState(AppLifecycleState::kHidden);
      }
      break;
    }
    case WindowStateEvent::kFocus: {
      bool first_focused_window = focused_windows_.empty();
      auto pair = focused_windows_.insert(hwnd);
      if (first_focused_window && pair.second &&
          state_ == AppLifecycleState::kInactive) {
        SetLifecycleState(AppLifecycleState::kResumed);
      }
      break;
    }
    case WindowStateEvent::kUnfocus: {
      if (focused_windows_.erase(hwnd) && focused_windows_.empty() &&
          state_ == AppLifecycleState::kResumed) {
        SetLifecycleState(AppLifecycleState::kInactive);
      }
      break;
    }
  }
}

Quit()

void flutter::WindowsLifecycleManager::Quit ( std::optional< HWND >  window, std::optional< WPARAM >  wparam, std::optional< LPARAM >  lparam, UINT  exit_code  )

virtual

Definition at line 21 of file windows_lifecycle_manager.cc.

                                                   {
  if (!hwnd.has_value()) {
    ::PostQuitMessage(exit_code);
  } else {
    BASE_CHECK(wparam.has_value() && lparam.has_value());
    sent_close_messages_[std::make_tuple(*hwnd, *wparam, *lparam)]++;
    DispatchMessage(*hwnd, WM_CLOSE, *wparam, *lparam);
  }
}

SetLifecycleState()

void flutter::WindowsLifecycleManager::SetLifecycleState ( AppLifecycleState  state )

virtual

Definition at line 195 of file windows_lifecycle_manager.cc.

                                                                       {
  if (state_ == state) {
    return;
  }
  state_ = state;
  if (engine_ && process_lifecycle_) {
    const char* state_name = AppLifecycleStateToString(state);
    engine_->SendPlatformMessage("flutter/lifecycle",
                                 reinterpret_cast<const uint8_t*>(state_name),
                                 strlen(state_name), nullptr, nullptr);
  }
}

WindowProc()

bool flutter::WindowsLifecycleManager::WindowProc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	w,
		LPARAM	l,
		LRESULT *	result
	)

Definition at line 65 of file windows_lifecycle_manager.cc.

                                                          {
  switch (msg) {
    // When WM_CLOSE is received from the final window of an application, we
    // send a request to the framework to see if the app should exit. If it
    // is, we re-dispatch a new WM_CLOSE message. In order to allow the new
    // message to reach other delegates, we ignore it here.
    case WM_CLOSE:
      return HandleCloseMessage(hwnd, wpar, lpar);
 
    // DWM composition can be disabled on Windows 7.
    // Notify the engine as this can result in screen tearing.
    case WM_DWMCOMPOSITIONCHANGED:
      engine_->OnDwmCompositionChanged();
      break;
 
    case WM_SIZE:
      if (wpar == SIZE_MAXIMIZED || wpar == SIZE_RESTORED) {
        OnWindowStateEvent(hwnd, WindowStateEvent::kShow);
      } else if (wpar == SIZE_MINIMIZED) {
        OnWindowStateEvent(hwnd, WindowStateEvent::kHide);
      }
      break;
 
    case WM_SHOWWINDOW:
      if (!wpar) {
        OnWindowStateEvent(hwnd, WindowStateEvent::kHide);
      } else {
        OnWindowStateEvent(hwnd, WindowStateEvent::kShow);
      }
      break;
 
    case WM_DESTROY:
      OnWindowStateEvent(hwnd, WindowStateEvent::kHide);
      break;
  }
  return false;
}

---

The documentation for this class was generated from the following files:

• shell/platform/windows/windows_lifecycle_manager.h
• shell/platform/windows/windows_lifecycle_manager.cc