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"

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

~PlatformHandler()

flutter::PlatformHandler::~PlatformHandler ( )

virtualdefault

Member Function Documentation

GetHasStrings()

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

protectedvirtual

Definition at line 294 of file platform_handler.cc.

                                                           {
  // TODO(loicsharma): Remove implicit view assumption.
  // https://github.com/flutter/flutter/issues/142845
  const FlutterWindowsView* view = engine_->view(kImplicitViewId);
  if (view == nullptr) {
    result->Error(kClipboardError,
                  "Clipboard is not available in Windows headless mode");
    return;
  }
 
  std::unique_ptr<ScopedClipboardInterface> clipboard =
      scoped_clipboard_provider_();
 
  bool hasStrings;
  int open_result = clipboard->Open(view->GetWindowHandle());
  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);
}

GetPlainText()

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

protectedvirtual

Definition at line 248 of file platform_handler.cc.

                        {
  // TODO(loicsharma): Remove implicit view assumption.
  // https://github.com/flutter/flutter/issues/142845
  const FlutterWindowsView* view = engine_->view(kImplicitViewId);
  if (view == nullptr) {
    result->Error(kClipboardError,
                  "Clipboard is not available in Windows headless mode");
    return;
  }
 
  std::unique_ptr<ScopedClipboardInterface> clipboard =
      scoped_clipboard_provider_();
 
  int open_result = clipboard->Open(view->GetWindowHandle());
  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);
}

QuitApplication()

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

protectedvirtual

Definition at line 440 of file platform_handler.cc.

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

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.

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

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

SetPlainText()

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

protectedvirtual

Definition at line 333 of file platform_handler.cc.

                                                           {
  // TODO(loicsharma): Remove implicit view assumption.
  // https://github.com/flutter/flutter/issues/142845
  const FlutterWindowsView* view = engine_->view(kImplicitViewId);
  if (view == nullptr) {
    result->Error(kClipboardError,
                  "Clipboard is not available in Windows headless mode");
    return;
  }
 
  std::unique_ptr<ScopedClipboardInterface> clipboard =
      scoped_clipboard_provider_();
 
  int open_result = clipboard->Open(view->GetWindowHandle());
  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();
}

SystemExitApplication()

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

protectedvirtual

Definition at line 376 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);
  }
}

SystemSoundPlay()

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

protectedvirtual

Definition at line 365 of file platform_handler.cc.

                                                           {
  if (sound_type.compare(kSoundTypeAlert) == 0) {
    MessageBeep(MB_OK);
    result->Success();
  } else {
    result->NotImplemented();
  }
}

Member Data Documentation

kClipboardError

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

staticconstexprprotected

Definition at line 104 of file platform_handler.h.

kExitTypeCancelable

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

staticconstexpr

Definition at line 44 of file platform_handler.h.

kExitTypeRequired

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

staticconstexpr

Definition at line 45 of file platform_handler.h.

kSoundTypeAlert

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

staticconstexprprotected

Definition at line 106 of file platform_handler.h.

---

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