#include <platform_handler.h>

Public Member Functions
	PlatformHandler (BinaryMessenger messenger, FlutterWindowsEngine engine, std::optional< std::function< std::unique_ptr< ScopedClipboardInterface >()>> scoped_clipboard_provider=std::nullopt)

virtual	~PlatformHandler ()

virtual void	RequestAppExit (std::optional< HWND > hwnd, std::optional< WPARAM > wparam, std::optional< LPARAM > lparam, AppExitType exit_type, UINT exit_code)

Static Public Attributes
static constexpr char	kExitTypeCancelable [] = "cancelable"

static constexpr char	kExitTypeRequired [] = "required"

Protected Member Functions
virtual void	GetPlainText (std::unique_ptr< MethodResult< rapidjson::Document >> result, std::string_view key)

virtual void	GetHasStrings (std::unique_ptr< MethodResult< rapidjson::Document >> result)

virtual void	SetPlainText (const std::string &text, std::unique_ptr< MethodResult< rapidjson::Document >> result)

virtual void	SystemSoundPlay (const std::string &sound_type, std::unique_ptr< MethodResult< rapidjson::Document >> result)

virtual void	SystemExitApplication (AppExitType exit_type, UINT exit_code, std::unique_ptr< MethodResult< rapidjson::Document >> result)

virtual void	QuitApplication (std::optional< HWND > hwnd, std::optional< WPARAM > wparam, std::optional< LPARAM > lparam, UINT exit_code)

virtual void	RequestAppExitSuccess (std::optional< HWND > hwnd, std::optional< WPARAM > wparam, std::optional< LPARAM > lparam, const rapidjson::Document *result, UINT exit_code)

Static Protected Attributes
static constexpr char	kClipboardError [] = "Clipboard error"

static constexpr char	kSoundTypeAlert [] = "SystemSoundType.alert"

static constexpr char	kSoundTypeClick [] = "SystemSoundType.click"

static constexpr char	kSoundTypeTick [] = "SystemSoundType.tick"

Detailed Description

Definition at line 33 of file platform_handler.h.

Constructor & Destructor Documentation

◆ PlatformHandler()

flutter::PlatformHandler::PlatformHandler	(	BinaryMessenger *	messenger,
		FlutterWindowsEngine *	engine,
		std::optional< std::function< std::unique_ptr< ScopedClipboardInterface >()>>	scoped_clipboard_provider = `std::nullopt`
	)

explicit

Definition at line 224 of file platform_handler.cc.

     : channel_(std::make_unique<MethodChannel<rapidjson::Document>>(
           messenger,
           kChannelName,
           &JsonMethodCodec::GetInstance())),
       engine_(engine) {
   channel_->SetMethodCallHandler(
       [this](const MethodCall<rapidjson::Document>& call,
              std::unique_ptr<MethodResult<rapidjson::Document>> result) {
         HandleMethodCall(call, std::move(result));
       });
   if (scoped_clipboard_provider.has_value()) {
     scoped_clipboard_provider_ = scoped_clipboard_provider.value();
   } else {
     scoped_clipboard_provider_ = []() {
       return std::make_unique<ScopedClipboard>();
     };
   }
  
   WNDCLASS window_class = RegisterWindowClass();
   window_handle_ =
       CreateWindowEx(0, window_class.lpszClassName, L"", 0, 0, 0, 0, 0,
                      HWND_MESSAGE, nullptr, window_class.hInstance, nullptr);
  
   if (window_handle_) {
     SetWindowLongPtr(window_handle_, GWLP_USERDATA,
                      reinterpret_cast<LONG_PTR>(this));
   } else {
     auto error = GetLastError();
     LPWSTR message = nullptr;
     size_t size = FormatMessageW(
         FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
             FORMAT_MESSAGE_IGNORE_INSERTS,
         NULL, error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
         reinterpret_cast<LPWSTR>(&message), 0, NULL);
     OutputDebugString(message);
     LocalFree(message);
   }
 }

◆ ~PlatformHandler()

flutter::PlatformHandler::~PlatformHandler ( )

virtual

Definition at line 268 of file platform_handler.cc.

                                   {
   if (window_handle_) {
     DestroyWindow(window_handle_);
     window_handle_ = nullptr;
   }
   UnregisterClass(kWindowClassName.c_str(), nullptr);
 }

Member Function Documentation

◆ GetHasStrings()

void flutter::PlatformHandler::GetHasStrings ( std::unique_ptr< MethodResult< rapidjson::Document >> result )

protectedvirtual

Definition at line 313 of file platform_handler.cc.

                                                            {
   std::unique_ptr<ScopedClipboardInterface> clipboard =
       scoped_clipboard_provider_();
  
   bool hasStrings;
   int open_result = clipboard->Open(window_handle_);
   if (open_result != kErrorSuccess) {
     // Swallow errors of type ERROR_ACCESS_DENIED. These happen when the app is
     // not in the foreground and GetHasStrings is irrelevant.
     // See https://github.com/flutter/flutter/issues/95817.
     if (open_result != kAccessDeniedErrorCode) {
       rapidjson::Document error_code;
       error_code.SetInt(open_result);
       result->Error(kClipboardError, "Unable to open clipboard", error_code);
       return;
     }
     hasStrings = false;
   } else {
     hasStrings = clipboard->HasString();
   }
  
   rapidjson::Document document;
   document.SetObject();
   rapidjson::Document::AllocatorType& allocator = document.GetAllocator();
   document.AddMember(rapidjson::Value(kValueKey, allocator),
                      rapidjson::Value(hasStrings), allocator);
   result->Success(document);
 }

References kAccessDeniedErrorCode, kClipboardError, kErrorSuccess, and kValueKey.

◆ GetPlainText()

void flutter::PlatformHandler::GetPlainText	(	std::unique_ptr< MethodResult< rapidjson::Document >>	result,
		std::string_view	key
	)

protectedvirtual

Definition at line 276 of file platform_handler.cc.

                         {
   std::unique_ptr<ScopedClipboardInterface> clipboard =
       scoped_clipboard_provider_();
  
   int open_result = clipboard->Open(window_handle_);
   if (open_result != kErrorSuccess) {
     rapidjson::Document error_code;
     error_code.SetInt(open_result);
     result->Error(kClipboardError, "Unable to open clipboard", error_code);
     return;
   }
   if (!clipboard->HasString()) {
     result->Success(rapidjson::Document());
     return;
   }
   std::variant<std::wstring, int> get_string_result = clipboard->GetString();
   if (std::holds_alternative<int>(get_string_result)) {
     rapidjson::Document error_code;
     error_code.SetInt(std::get<int>(get_string_result));
     result->Error(kClipboardError, "Unable to get clipboard data", error_code);
     return;
   }
  
   rapidjson::Document document;
   document.SetObject();
   rapidjson::Document::AllocatorType& allocator = document.GetAllocator();
   document.AddMember(
       rapidjson::Value(key.data(), allocator),
       rapidjson::Value(
           fml::WideStringToUtf8(std::get<std::wstring>(get_string_result)),
           allocator),
       allocator);
   result->Success(document);
 }

References kClipboardError, kErrorSuccess, and key.

◆ QuitApplication()

void flutter::PlatformHandler::QuitApplication	(	std::optional< HWND >	hwnd,
		std::optional< WPARAM >	wparam,
		std::optional< LPARAM >	lparam,
		UINT	exit_code
	)

protectedvirtual

Definition at line 447 of file platform_handler.cc.

                                                       {
   engine_->OnQuit(hwnd, wparam, lparam, exit_code);
 }

References flutter::FlutterWindowsEngine::OnQuit().

Referenced by RequestAppExitSuccess(), and SystemExitApplication().

◆ RequestAppExit()

void flutter::PlatformHandler::RequestAppExit	(	std::optional< HWND >	hwnd,
		std::optional< WPARAM >	wparam,
		std::optional< LPARAM >	lparam,
		AppExitType	exit_type,
		UINT	exit_code
	)

virtual

Definition at line 408 of file platform_handler.cc.

                                                      {
   auto callback = std::make_unique<MethodResultFunctions<rapidjson::Document>>(
       [this, exit_code, hwnd, wparam,
        lparam](const rapidjson::Document* response) {
         RequestAppExitSuccess(hwnd, wparam, lparam, response, exit_code);
       },
       nullptr, nullptr);
   auto args = std::make_unique<rapidjson::Document>();
   args->SetObject();
   args->GetObjectW().AddMember(
       kExitTypeKey, std::string(kExitTypeNames[static_cast<int>(exit_type)]),
       args->GetAllocator());
   channel_->InvokeMethod(kRequestAppExitMethod, std::move(args),
                          std::move(callback));
 }

References callback, kExitTypeKey, flutter::kExitTypeNames, kRequestAppExitMethod, and RequestAppExitSuccess().

Referenced by SystemExitApplication().

◆ RequestAppExitSuccess()

void flutter::PlatformHandler::RequestAppExitSuccess	(	std::optional< HWND >	hwnd,
		std::optional< WPARAM >	wparam,
		std::optional< LPARAM >	lparam,
		const rapidjson::Document *	result,
		UINT	exit_code
	)

protectedvirtual

Definition at line 428 of file platform_handler.cc.

                                                             {
   rapidjson::Value::ConstMemberIterator itr =
       result->FindMember(kExitResponseKey);
   if (itr == result->MemberEnd() || !itr->value.IsString()) {
     FML_LOG(ERROR) << "Application request response did not contain a valid "
                       "response value";
     return;
   }
   const std::string& exit_type = itr->value.GetString();
  
   if (exit_type.compare(kExitResponseExit) == 0) {
     QuitApplication(hwnd, wparam, lparam, exit_code);
   }
 }

References kExitResponseExit, kExitResponseKey, and QuitApplication().

Referenced by RequestAppExit().

◆ SetPlainText()

void flutter::PlatformHandler::SetPlainText	(	const std::string &	text,
		std::unique_ptr< MethodResult< rapidjson::Document >>	result
	)

protectedvirtual

Definition at line 343 of file platform_handler.cc.

                                                            {
   std::unique_ptr<ScopedClipboardInterface> clipboard =
       scoped_clipboard_provider_();
  
   int open_result = clipboard->Open(window_handle_);
   if (open_result != kErrorSuccess) {
     rapidjson::Document error_code;
     error_code.SetInt(open_result);
     result->Error(kClipboardError, "Unable to open clipboard", error_code);
     return;
   }
   int set_result = clipboard->SetString(fml::Utf8ToWideString(text));
   if (set_result != kErrorSuccess) {
     rapidjson::Document error_code;
     error_code.SetInt(set_result);
     result->Error(kClipboardError, "Unable to set clipboard data", error_code);
     return;
   }
   result->Success();
 }

References kClipboardError, kErrorSuccess, and text.

◆ SystemExitApplication()

void flutter::PlatformHandler::SystemExitApplication	(	AppExitType	exit_type,
		UINT	exit_code,
		std::unique_ptr< MethodResult< rapidjson::Document >>	result
	)

protectedvirtual

Definition at line 383 of file platform_handler.cc.

                                                            {
   rapidjson::Document result_doc;
   result_doc.SetObject();
   if (exit_type == AppExitType::required) {
     QuitApplication(std::nullopt, std::nullopt, std::nullopt, exit_code);
     result_doc.GetObjectW().AddMember(kExitResponseKey, kExitResponseExit,
                                       result_doc.GetAllocator());
     result->Success(result_doc);
   } else {
     RequestAppExit(std::nullopt, std::nullopt, std::nullopt, exit_type,
                    exit_code);
     result_doc.GetObjectW().AddMember(kExitResponseKey, kExitResponseCancel,
                                       result_doc.GetAllocator());
     result->Success(result_doc);
   }
 }

References kExitResponseCancel, kExitResponseExit, kExitResponseKey, QuitApplication(), RequestAppExit(), and flutter::required.

◆ SystemSoundPlay()

void flutter::PlatformHandler::SystemSoundPlay	(	const std::string &	sound_type,
		std::unique_ptr< MethodResult< rapidjson::Document >>	result
	)

protectedvirtual

Definition at line 366 of file platform_handler.cc.

                                                            {
   if (sound_type.compare(kSoundTypeAlert) == 0) {
     MessageBeep(MB_OK);
     result->Success();
   } else if (sound_type.compare(kSoundTypeClick) == 0) {
     // No-op, as there is no system sound for key presses.
     result->Success();
   } else if (sound_type.compare(kSoundTypeTick) == 0) {
     // No-op, as there is no system sound for ticks.
     result->Success();
   } else {
     result->NotImplemented();
   }
 }

References kSoundTypeAlert, kSoundTypeClick, and kSoundTypeTick.

Member Data Documentation

◆ kClipboardError

constexpr char flutter::PlatformHandler::kClipboardError[] = "Clipboard error"

staticconstexprprotected

Definition at line 104 of file platform_handler.h.

Referenced by GetHasStrings(), GetPlainText(), and SetPlainText().

◆ kExitTypeCancelable

constexpr char flutter::PlatformHandler::kExitTypeCancelable[] = "cancelable"

staticconstexpr

Definition at line 44 of file platform_handler.h.

Referenced by flutter::StringToAppExitType().

◆ kExitTypeRequired

constexpr char flutter::PlatformHandler::kExitTypeRequired[] = "required"

staticconstexpr

Definition at line 45 of file platform_handler.h.

Referenced by flutter::StringToAppExitType().

◆ kSoundTypeAlert

constexpr char flutter::PlatformHandler::kSoundTypeAlert[] = "SystemSoundType.alert"

staticconstexprprotected

Definition at line 106 of file platform_handler.h.

Referenced by SystemSoundPlay().

◆ kSoundTypeClick

constexpr char flutter::PlatformHandler::kSoundTypeClick[] = "SystemSoundType.click"

staticconstexprprotected

Definition at line 107 of file platform_handler.h.

Referenced by SystemSoundPlay().

◆ kSoundTypeTick

constexpr char flutter::PlatformHandler::kSoundTypeTick[] = "SystemSoundType.tick"

staticconstexprprotected

Definition at line 108 of file platform_handler.h.

Referenced by SystemSoundPlay().

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

shell/platform/windows/platform_handler.h
shell/platform/windows/platform_handler.cc

Public Member Functions

Static Public Attributes

Protected Member Functions

Static Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ PlatformHandler()

◆ ~PlatformHandler()

Member Function Documentation

◆ GetHasStrings()

◆ GetPlainText()

◆ QuitApplication()

◆ RequestAppExit()

◆ RequestAppExitSuccess()

◆ SetPlainText()

◆ SystemExitApplication()

◆ SystemSoundPlay()

Member Data Documentation

◆ kClipboardError

◆ kExitTypeCancelable

◆ kExitTypeRequired

◆ kSoundTypeAlert

◆ kSoundTypeClick

◆ kSoundTypeTick