flutter::PlatformHandler Class Reference

#include <platform_handler.h>

Public Member Functions
	PlatformHandler (flutter::BinaryMessenger *messenger, GLFWwindow *window)
	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 18 of file platform_handler.h.

Constructor & Destructor Documentation

PlatformHandler() [1/2]

flutter::PlatformHandler::PlatformHandler ( flutter::BinaryMessenger *  messenger, GLFWwindow *  window  )

explicit

Definition at line 26 of file platform_handler.cc.

    : channel_(std::make_unique<flutter::MethodChannel<rapidjson::Document>>(
          messenger,
          kChannelName,
          &flutter::JsonMethodCodec::GetInstance())),
      window_(window) {
  channel_->SetMethodCallHandler(
      [this](
          const flutter::MethodCall<rapidjson::Document>& call,
          std::unique_ptr<flutter::MethodResult<rapidjson::Document>> result) {
        HandleMethodCall(call, std::move(result));
      });
}

PlatformHandler() [2/2]

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);
  }
}

References error, GetLastError(), message, and flutter::size.

~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, key, and fml::WideStringToUtf8().

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 args, 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 FML_LOG, 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, text, and fml::Utf8ToWideString().

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/glfw/platform_handler.h
• shell/platform/windows/platform_handler.h
• shell/platform/glfw/platform_handler.cc
• shell/platform/windows/platform_handler.cc