| Flutter Windows Embedder |

Public Member Functions | Static Public Attributes | Protected Member Functions | Static Protected Attributes | List of all members
flutter::PlatformHandler Class Reference

`#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"

## 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 222 of file platform_handler.cc.

227 : channel_(std::make_unique<MethodChannel<rapidjson::Document>>(
228 messenger,
229 kChannelName,
230 &JsonMethodCodec::GetInstance())),
231 engine_(engine) {
232 channel_->SetMethodCallHandler(
233 [this](const MethodCall<rapidjson::Document>& call,
234 std::unique_ptr<MethodResult<rapidjson::Document>> result) {
235 HandleMethodCall(call, std::move(result));
236 });
237 if (scoped_clipboard_provider.has_value()) {
238 scoped_clipboard_provider_ = scoped_clipboard_provider.value();
239 } else {
240 scoped_clipboard_provider_ = []() {
241 return std::make_unique<ScopedClipboard>();
242 };
243 }
244 }

## ◆ ~PlatformHandler()

flutter::PlatformHandler::~PlatformHandler | ( |  | ) |
| virtual default

## Member Function Documentation

## ◆ GetHasStrings()

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

Definition at line 294 of file platform_handler.cc.

295 {
296 // TODO(loicsharma): Remove implicit view assumption.
297 // https://github.com/flutter/flutter/issues/142845
298 const FlutterWindowsView* view = engine_->view(kImplicitViewId);
299 if (view == nullptr) {
300 result->Error(kClipboardError,
301 "Clipboard is not available in Windows headless mode");
302 return;
303 }
304
305 std::unique_ptr<ScopedClipboardInterface> clipboard =
306 scoped_clipboard_provider_();
307
308 bool hasStrings;
309 int open_result = clipboard->Open(view->GetWindowHandle());
310 if (open_result != kErrorSuccess) {
311 // Swallow errors of type ERROR_ACCESS_DENIED. These happen when the app is
312 // not in the foreground and GetHasStrings is irrelevant.
313 // See https://github.com/flutter/flutter/issues/95817.
314 if (open_result != kAccessDeniedErrorCode) {
315 rapidjson::Document error_code;
316 error_code.SetInt(open_result);
317 result->Error(kClipboardError, "Unable to open clipboard", error_code);
318 return;
319 }
320 hasStrings = false;
321 } else {
322 hasStrings = clipboard->HasString();
323 }
324
325 rapidjson::Document document;
326 document.SetObject();
327 rapidjson::Document::AllocatorType& allocator = document.GetAllocator();
328 document.AddMember(rapidjson::Value(kValueKey, allocator),
329 rapidjson::Value(hasStrings), allocator);
330 result->Success(document);
331 }

References flutter::FlutterWindowsView::GetWindowHandle(), kAccessDeniedErrorCode, kClipboardError, kErrorSuccess, flutter::kImplicitViewId, kValueKey, and flutter::FlutterWindowsEngine::view().

## ◆ GetPlainText()

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

Definition at line 248 of file platform_handler.cc.

250 {
251 // TODO(loicsharma): Remove implicit view assumption.
252 // https://github.com/flutter/flutter/issues/142845
253 const FlutterWindowsView* view = engine_->view(kImplicitViewId);
254 if (view == nullptr) {
255 result->Error(kClipboardError,
256 "Clipboard is not available in Windows headless mode");
257 return;
258 }
259
260 std::unique_ptr<ScopedClipboardInterface> clipboard =
261 scoped_clipboard_provider_();
262
263 int open_result = clipboard->Open(view->GetWindowHandle());
264 if (open_result != kErrorSuccess) {
265 rapidjson::Document error_code;
266 error_code.SetInt(open_result);
267 result->Error(kClipboardError, "Unable to open clipboard", error_code);
268 return;
269 }
270 if (!clipboard->HasString()) {
271 result->Success(rapidjson::Document());
272 return;
273 }
274 std::variant<std::wstring, int> get_string_result = clipboard->GetString();
275 if (std::holds_alternative<int>(get_string_result)) {
276 rapidjson::Document error_code;
277 error_code.SetInt(std::get<int>(get_string_result));
278 result->Error(kClipboardError, "Unable to get clipboard data", error_code);
279 return;
280 }
281
282 rapidjson::Document document;
283 document.SetObject();
284 rapidjson::Document::AllocatorType& allocator = document.GetAllocator();
285 document.AddMember(
286 rapidjson::Value(key.data(), allocator),
287 rapidjson::Value(
288 fml::WideStringToUtf8(std::get<std::wstring>(get_string_result)),
289 allocator),
290 allocator);
291 result->Success(document);
292 }

References flutter::FlutterWindowsView::GetWindowHandle(), kClipboardError, kErrorSuccess, key, flutter::kImplicitViewId, and flutter::FlutterWindowsEngine::view().

## ◆ QuitApplication()

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

Definition at line 440 of file platform_handler.cc.

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

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 401 of file platform_handler.cc.

405 {
406 auto callback = std::make_unique<MethodResultFunctions<rapidjson::Document>>(
407 [this, exit_code, hwnd, wparam,
408 lparam](const rapidjson::Document* response) {
409 RequestAppExitSuccess(hwnd, wparam, lparam, response, exit_code);
410 },
411 nullptr, nullptr);
412 auto args = std::make_unique<rapidjson::Document>();
413 args->SetObject();
414 args->GetObjectW().AddMember(
415 kExitTypeKey, std::string(kExitTypeNames[static_cast<int>(exit_type)]),
416 args->GetAllocator());
417 channel_->InvokeMethod(kRequestAppExitMethod, std::move(args),
418 std::move(callback));
419 }

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
| ) |  |
| protected virtual

Definition at line 421 of file platform_handler.cc.

425 {
426 rapidjson::Value::ConstMemberIterator itr =
427 result->FindMember(kExitResponseKey);
428 if (itr == result->MemberEnd() || !itr->value.IsString()) {
429 FML_LOG(ERROR) << "Application request response did not contain a valid "
430 "response value";
431 return;
432 }
433 const std::string& exit_type = itr->value.GetString();
434
435 if (exit_type.compare(kExitResponseExit) == 0) {
436 QuitApplication(hwnd, wparam, lparam, exit_code);
437 }
438 }

References kExitResponseExit, kExitResponseKey, and QuitApplication().

Referenced by RequestAppExit().

## ◆ SetPlainText()

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

Definition at line 333 of file platform_handler.cc.

335 {
336 // TODO(loicsharma): Remove implicit view assumption.
337 // https://github.com/flutter/flutter/issues/142845
338 const FlutterWindowsView* view = engine_->view(kImplicitViewId);
339 if (view == nullptr) {
340 result->Error(kClipboardError,
341 "Clipboard is not available in Windows headless mode");
342 return;
343 }
344
345 std::unique_ptr<ScopedClipboardInterface> clipboard =
346 scoped_clipboard_provider_();
347
348 int open_result = clipboard->Open(view->GetWindowHandle());
349 if (open_result != kErrorSuccess) {
350 rapidjson::Document error_code;
351 error_code.SetInt(open_result);
352 result->Error(kClipboardError, "Unable to open clipboard", error_code);
353 return;
354 }
355 int set_result = clipboard->SetString(fml::Utf8ToWideString(text));
356 if (set_result != kErrorSuccess) {
357 rapidjson::Document error_code;
358 error_code.SetInt(set_result);
359 result->Error(kClipboardError, "Unable to set clipboard data", error_code);
360 return;
361 }
362 result->Success();
363 }

References flutter::FlutterWindowsView::GetWindowHandle(), kClipboardError, kErrorSuccess, flutter::kImplicitViewId, text, and flutter::FlutterWindowsEngine::view().

## ◆ SystemExitApplication()

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

Definition at line 376 of file platform_handler.cc.

379 {
380 rapidjson::Document result_doc;
381 result_doc.SetObject();
382 if (exit_type == AppExitType::required) {
383 QuitApplication(std::nullopt, std::nullopt, std::nullopt, exit_code);
384 result_doc.GetObjectW().AddMember(kExitResponseKey, kExitResponseExit,
385 result_doc.GetAllocator());
386 result->Success(result_doc);
387 } else {
388 RequestAppExit(std::nullopt, std::nullopt, std::nullopt, exit_type,
389 exit_code);
390 result_doc.GetObjectW().AddMember(kExitResponseKey, kExitResponseCancel,
391 result_doc.GetAllocator());
392 result->Success(result_doc);
393 }
394 }

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
| ) |  |
| protected virtual

Definition at line 365 of file platform_handler.cc.

367 {
368 if (sound_type.compare(kSoundTypeAlert) == 0) {
369 MessageBeep(MB_OK);
370 result->Success();
371 } else {
372 result->NotImplemented();
373 }
374 }

References kSoundTypeAlert.

## Member Data Documentation

## ◆ kClipboardError

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

Definition at line 104 of file platform_handler.h.

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

## ◆ kExitTypeCancelable

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

Definition at line 44 of file platform_handler.h.

Referenced by flutter::StringToAppExitType().

## ◆ kExitTypeRequired

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

Definition at line 45 of file platform_handler.h.

Referenced by flutter::StringToAppExitType().

## ◆ kSoundTypeAlert

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

Definition at line 106 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

flutter::kImplicitViewId
constexpr FlutterViewId kImplicitViewId
Definition: flutter_windows_engine.h:55
flutter::FlutterWindowsEngine::view
FlutterWindowsView * view(FlutterViewId view_id) const
Definition: flutter_windows_engine.cc:656
kValueKey
static constexpr char kValueKey[]
Definition: platform_handler.cc:43
flutter::PlatformHandler::QuitApplication
virtual void QuitApplication(std::optional< HWND > hwnd, std::optional< WPARAM > wparam, std::optional< LPARAM > lparam, UINT exit_code)
Definition: platform_handler.cc:440
flutter::FlutterWindowsEngine::OnQuit
void OnQuit(std::optional< HWND > hwnd, std::optional< WPARAM > wparam, std::optional< LPARAM > lparam, UINT exit_code)
Definition: flutter_windows_engine.cc:946
flutter::JsonMethodCodec::GetInstance
static const JsonMethodCodec & GetInstance()
Definition: json_method_codec.cc:36
kRequestAppExitMethod
static constexpr char kRequestAppExitMethod[]
Definition: platform_handler.cc:25
flutter::PlatformHandler::RequestAppExit
virtual void RequestAppExit(std::optional< HWND > hwnd, std::optional< WPARAM > wparam, std::optional< LPARAM > lparam, AppExitType exit_type, UINT exit_code)
Definition: platform_handler.cc:401
text
std::u16string text
Definition: keyboard_unittests.cc:332
flutter::PlatformHandler::kClipboardError
static constexpr char kClipboardError[]
Definition: platform_handler.h:104
kExitResponseKey
static constexpr char kExitResponseKey[]
Definition: platform_handler.cc:34
kChannelName
static constexpr char kChannelName[]
Definition: platform_handler.cc:19
kErrorSuccess
static constexpr int kErrorSuccess
Definition: platform_handler.cc:45
kExitResponseExit
static constexpr char kExitResponseExit[]
Definition: platform_handler.cc:36
flutter::kExitTypeNames
static constexpr const char * kExitTypeNames[]
Definition: platform_handler.cc:398
kAccessDeniedErrorCode
static constexpr int kAccessDeniedErrorCode
Definition: platform_handler.cc:44
flutter::PlatformHandler::RequestAppExitSuccess
virtual void RequestAppExitSuccess(std::optional< HWND > hwnd, std::optional< WPARAM > wparam, std::optional< LPARAM > lparam, const rapidjson::Document *result, UINT exit_code)
Definition: platform_handler.cc:421
flutter::PlatformHandler::kSoundTypeAlert
static constexpr char kSoundTypeAlert[]
Definition: platform_handler.h:106
key
int key
Definition: keyboard_key_handler_unittests.cc:114
flutter::AppExitType::required
@ required
kExitResponseCancel
static constexpr char kExitResponseCancel[]
Definition: platform_handler.cc:35
callback
FlutterDesktopBinaryReply callback
Definition: flutter_windows_view_unittests.cc:52
kExitTypeKey
static constexpr char kExitTypeKey[]
Definition: platform_handler.cc:32