flutter::PlatformConfiguration Class Reference

A class for holding and distributing platform-level information to and from the Dart code in Flutter's framework. More...

#include <platform_configuration.h>

Public Member Functions
	PlatformConfiguration (PlatformConfigurationClient *client)
	Creates a new PlatformConfiguration, typically created by the RuntimeController. More...
	PlatformConfiguration (const PlatformConfiguration &)=delete
PlatformConfiguration &	operator= (const PlatformConfiguration &)=delete
	~PlatformConfiguration ()
PlatformConfigurationClient *	client () const
	Access to the platform configuration client (which typically is implemented by the RuntimeController). More...
void	DidCreateIsolate ()
	Called by the RuntimeController once it has created the root isolate, so that the PlatformController can get a handle to the 'dart:ui' library. More...
bool	AddView (int64_t view_id, const ViewportMetrics &view_metrics)
	Notify the framework that a new view is available. More...
bool	RemoveView (int64_t view_id)
	Notify the framework that a view is no longer available. More...
bool	UpdateViewMetrics (int64_t view_id, const ViewportMetrics &metrics)
	Update the view metrics for the specified view. More...
void	UpdateDisplays (const std::vector< DisplayData > &displays)
	Update the specified display data in the framework. More...
void	UpdateLocales (const std::vector< std::string > &locales)
	Update the specified locale data in the framework. More...
void	UpdateUserSettingsData (const std::string &data)
	Update the user settings data in the framework. More...
void	UpdateInitialLifecycleState (const std::string &data)
	Updates the lifecycle state data in the framework. More...
void	UpdateSemanticsEnabled (bool enabled)
	Notifies the PlatformConfiguration that the embedder has expressed an opinion about whether the accessibility tree should be generated or not. This call originates in the platform view and is forwarded to the PlatformConfiguration here by the engine. More...
void	UpdateAccessibilityFeatures (int32_t flags)
	Forward the preference of accessibility features that must be enabled in the semantics tree to the framwork. More...
void	DispatchPlatformMessage (std::unique_ptr< PlatformMessage > message)
	Notifies the PlatformConfiguration that the client has sent it a message. This call originates in the platform view and has been forwarded through the engine to here. More...
void	DispatchPointerDataPacket (const PointerDataPacket &packet)
	Notifies the PlatformConfiguration that the client has sent it pointer events. This call originates in the platform view and has been forwarded through the engine to here. More...
void	DispatchSemanticsAction (int32_t node_id, SemanticsAction action, fml::MallocMapping args)
	Notifies the framework that the embedder encountered an accessibility related action on the specified node. This call originates on the platform view and has been forwarded to the platform configuration here by the engine. More...
void	BeginFrame (fml::TimePoint frame_time, uint64_t frame_number)
	Notifies the framework that it is time to begin working on a new frame previously scheduled via a call to PlatformConfigurationClient::ScheduleFrame. This call originates in the animator. More...
void	ReportTimings (std::vector< int64_t > timings)
	Dart code cannot fully measure the time it takes for a specific frame to be rendered. This is because Dart code only runs on the UI task runner. That is only a small part of the overall frame workload. The raster task runner frame workload is executed on a thread where Dart code cannot run (and hence instrument). Besides, due to the pipelined nature of rendering in Flutter, there may be multiple frame workloads being processed at any given time. However, for non-Timeline based profiling, it is useful for trace collection and processing to happen in Dart. To do this, the raster task runner frame workloads need to be instrumented separately. After a set number of these profiles have been gathered, they need to be reported back to Dart code. The engine reports this extra instrumentation information back to the framework by invoking this method at predefined intervals. More...
const ViewportMetrics *	GetMetrics (int view_id)
	Retrieves the viewport metrics with the given ID managed by the PlatformConfiguration. More...
void	CompletePlatformMessageResponse (int response_id, std::vector< uint8_t > data)
	Responds to a previous platform message to the engine from the framework. More...
void	CompletePlatformMessageEmptyResponse (int response_id)
	Responds to a previous platform message to the engine from the framework with an empty response. More...
Dart_Handle	on_error ()

Detailed Description

A class for holding and distributing platform-level information to and from the Dart code in Flutter's framework.

It handles communication between the engine and the framework.

It communicates with the RuntimeController through the use of a PlatformConfigurationClient interface, which the RuntimeController defines.

Definition at line 271 of file platform_configuration.h.

Constructor & Destructor Documentation

PlatformConfiguration() [1/2]

flutter::PlatformConfiguration::PlatformConfiguration ( PlatformConfigurationClient *  client )

explicit

Creates a new PlatformConfiguration, typically created by the RuntimeController.

Parameters

[in]

client

The PlatformConfigurationClient to be injected into the PlatformConfiguration. This client is used to forward requests to the RuntimeController.

Definition at line 34 of file platform_configuration.cc.

    : client_(client) {}

PlatformConfiguration() [2/2]

flutter::PlatformConfiguration::PlatformConfiguration ( const PlatformConfiguration &  )

delete

~PlatformConfiguration()

flutter::PlatformConfiguration::~PlatformConfiguration

(

)

Definition at line 38 of file platform_configuration.cc.

{}

Member Function Documentation

AddView()

bool flutter::PlatformConfiguration::AddView	(	int64_t	view_id,
		const ViewportMetrics &	view_metrics
	)

Notify the framework that a new view is available.

        A view must be added before other methods can refer to it,
        including the implicit view. Adding a view that already exists
        triggers an assertion.

Parameters

[in]	view_id	The ID of the new view.
[in]	viewport_metrics	The initial viewport metrics for the view.

Returns

Whether the view was added.

Definition at line 86 of file platform_configuration.cc.

                                                                         {
  auto [view_iterator, insertion_happened] =
      metrics_.emplace(view_id, view_metrics);
  if (!insertion_happened) {
    FML_LOG(ERROR) << "View #" << view_id << " already exists.";
    return false;
  }
 
  std::shared_ptr<tonic::DartState> dart_state = add_view_.dart_state().lock();
  if (!dart_state) {
    return false;
  }
  tonic::DartState::Scope scope(dart_state);
  tonic::CheckAndHandleError(tonic::DartInvoke(
      add_view_.Get(),
      {
          tonic::ToDart(view_id),
          tonic::ToDart(view_metrics.device_pixel_ratio),
          tonic::ToDart(view_metrics.physical_width),
          tonic::ToDart(view_metrics.physical_height),
          tonic::ToDart(view_metrics.physical_padding_top),
          tonic::ToDart(view_metrics.physical_padding_right),
          tonic::ToDart(view_metrics.physical_padding_bottom),
          tonic::ToDart(view_metrics.physical_padding_left),
          tonic::ToDart(view_metrics.physical_view_inset_top),
          tonic::ToDart(view_metrics.physical_view_inset_right),
          tonic::ToDart(view_metrics.physical_view_inset_bottom),
          tonic::ToDart(view_metrics.physical_view_inset_left),
          tonic::ToDart(view_metrics.physical_system_gesture_inset_top),
          tonic::ToDart(view_metrics.physical_system_gesture_inset_right),
          tonic::ToDart(view_metrics.physical_system_gesture_inset_bottom),
          tonic::ToDart(view_metrics.physical_system_gesture_inset_left),
          tonic::ToDart(view_metrics.physical_touch_slop),
          tonic::ToDart(view_metrics.physical_display_features_bounds),
          tonic::ToDart(view_metrics.physical_display_features_type),
          tonic::ToDart(view_metrics.physical_display_features_state),
          tonic::ToDart(view_metrics.display_id),
      }));
  return true;
}

BeginFrame()

void flutter::PlatformConfiguration::BeginFrame	(	fml::TimePoint	frame_time,
		uint64_t	frame_number
	)

Notifies the framework that it is time to begin working on a new frame previously scheduled via a call to PlatformConfigurationClient::ScheduleFrame. This call originates in the animator.

The frame time given as the argument indicates the point at which the current frame interval began. It is very slightly (because of scheduling overhead) in the past. If a new layer tree is not produced and given to the raster task runner within one frame interval from this point, the Flutter application will jank.

This method calls the ::_beginFrame method in hooks.dart.

Parameters

[in]	frame_time	The point at which the current frame interval began. May be used by animation interpolators, physics simulations, etc..
[in]	frame_number	The frame number recorded by the animator. Used by the framework to associate frame specific debug information with frame timings and timeline events.

Definition at line 371 of file platform_configuration.cc.

                                                              {
  std::shared_ptr<tonic::DartState> dart_state =
      begin_frame_.dart_state().lock();
  if (!dart_state) {
    return;
  }
  tonic::DartState::Scope scope(dart_state);
 
  int64_t microseconds = (frameTime - fml::TimePoint()).ToMicroseconds();
 
  tonic::CheckAndHandleError(
      tonic::DartInvoke(begin_frame_.Get(), {
                                                Dart_NewInteger(microseconds),
                                                Dart_NewInteger(frame_number),
                                            }));
 
  UIDartState::Current()->FlushMicrotasksNow();
 
  tonic::CheckAndHandleError(tonic::DartInvokeVoid(draw_frame_.Get()));
}

client()

PlatformConfigurationClient * flutter::PlatformConfiguration::client ( ) const

inline

Access to the platform configuration client (which typically is implemented by the RuntimeController).

Returns

Returns the client used to construct this PlatformConfiguration.

Definition at line 296 of file platform_configuration.h.

{ return client_; }

CompletePlatformMessageEmptyResponse()

void flutter::PlatformConfiguration::CompletePlatformMessageEmptyResponse

(

int

response_id

)

Responds to a previous platform message to the engine from the framework with an empty response.

Parameters

[in]

response_id

The unique id that identifies the original platform message to respond to.

Definition at line 429 of file platform_configuration.cc.

                     {
  if (!response_id) {
    return;
  }
  auto it = pending_responses_.find(response_id);
  if (it == pending_responses_.end()) {
    return;
  }
  auto response = std::move(it->second);
  pending_responses_.erase(it);
  response->CompleteEmpty();
}

CompletePlatformMessageResponse()

void flutter::PlatformConfiguration::CompletePlatformMessageResponse	(	int	response_id,
		std::vector< uint8_t >	data
	)

Responds to a previous platform message to the engine from the framework.

Parameters

[in]	response_id	The unique id that identifies the original platform message to respond to.
[in]	data	The data to send back in the response.

Definition at line 443 of file platform_configuration.cc.

                             {
  if (!response_id) {
    return;
  }
  auto it = pending_responses_.find(response_id);
  if (it == pending_responses_.end()) {
    return;
  }
  auto response = std::move(it->second);
  pending_responses_.erase(it);
  response->Complete(std::make_unique<fml::DataMapping>(std::move(data)));
}

DidCreateIsolate()

void flutter::PlatformConfiguration::DidCreateIsolate

(

)

Called by the RuntimeController once it has created the root isolate, so that the PlatformController can get a handle to the 'dart:ui' library.

It uses the handle to call the hooks in hooks.dart.

Definition at line 40 of file platform_configuration.cc.

                                             {
  Dart_Handle library = Dart_LookupLibrary(tonic::ToDart("dart:ui"));
 
  on_error_.Set(tonic::DartState::Current(),
                Dart_GetField(library, tonic::ToDart("_onError")));
  add_view_.Set(tonic::DartState::Current(),
                Dart_GetField(library, tonic::ToDart("_addView")));
  remove_view_.Set(tonic::DartState::Current(),
                   Dart_GetField(library, tonic::ToDart("_removeView")));
  update_window_metrics_.Set(
      tonic::DartState::Current(),
      Dart_GetField(library, tonic::ToDart("_updateWindowMetrics")));
  update_displays_.Set(
      tonic::DartState::Current(),
      Dart_GetField(library, tonic::ToDart("_updateDisplays")));
  update_locales_.Set(tonic::DartState::Current(),
                      Dart_GetField(library, tonic::ToDart("_updateLocales")));
  update_user_settings_data_.Set(
      tonic::DartState::Current(),
      Dart_GetField(library, tonic::ToDart("_updateUserSettingsData")));
  update_initial_lifecycle_state_.Set(
      tonic::DartState::Current(),
      Dart_GetField(library, tonic::ToDart("_updateInitialLifecycleState")));
  update_semantics_enabled_.Set(
      tonic::DartState::Current(),
      Dart_GetField(library, tonic::ToDart("_updateSemanticsEnabled")));
  update_accessibility_features_.Set(
      tonic::DartState::Current(),
      Dart_GetField(library, tonic::ToDart("_updateAccessibilityFeatures")));
  dispatch_platform_message_.Set(
      tonic::DartState::Current(),
      Dart_GetField(library, tonic::ToDart("_dispatchPlatformMessage")));
  dispatch_pointer_data_packet_.Set(
      tonic::DartState::Current(),
      Dart_GetField(library, tonic::ToDart("_dispatchPointerDataPacket")));
  dispatch_semantics_action_.Set(
      tonic::DartState::Current(),
      Dart_GetField(library, tonic::ToDart("_dispatchSemanticsAction")));
  begin_frame_.Set(tonic::DartState::Current(),
                   Dart_GetField(library, tonic::ToDart("_beginFrame")));
  draw_frame_.Set(tonic::DartState::Current(),
                  Dart_GetField(library, tonic::ToDart("_drawFrame")));
  report_timings_.Set(tonic::DartState::Current(),
                      Dart_GetField(library, tonic::ToDart("_reportTimings")));
}

DispatchPlatformMessage()

void flutter::PlatformConfiguration::DispatchPlatformMessage

(

std::unique_ptr< PlatformMessage >

message

)

Notifies the PlatformConfiguration that the client has sent it a message. This call originates in the platform view and has been forwarded through the engine to here.

Parameters

[in]

message

The message sent from the embedder to the Dart application.

Definition at line 296 of file platform_configuration.cc.

                                            {
  std::shared_ptr<tonic::DartState> dart_state =
      dispatch_platform_message_.dart_state().lock();
  if (!dart_state) {
    FML_DLOG(WARNING)
        << "Dropping platform message for lack of DartState on channel: "
        << message->channel();
    return;
  }
  tonic::DartState::Scope scope(dart_state);
  Dart_Handle data_handle =
      (message->hasData()) ? ToByteData(message->data()) : Dart_Null();
  if (Dart_IsError(data_handle)) {
    FML_DLOG(WARNING)
        << "Dropping platform message because of a Dart error on channel: "
        << message->channel();
    return;
  }
 
  int response_id = 0;
  if (auto response = message->response()) {
    response_id = next_response_id_++;
    pending_responses_[response_id] = response;
  }
 
  tonic::CheckAndHandleError(
      tonic::DartInvoke(dispatch_platform_message_.Get(),
                        {tonic::ToDart(message->channel()), data_handle,
                         tonic::ToDart(response_id)}));
}

DispatchPointerDataPacket()

void flutter::PlatformConfiguration::DispatchPointerDataPacket

(

const PointerDataPacket &

packet

)

Notifies the PlatformConfiguration that the client has sent it pointer events. This call originates in the platform view and has been forwarded through the engine to here.

Parameters

[in]

packet

The pointer event(s) serialized into a packet.

Definition at line 328 of file platform_configuration.cc.

                                     {
  std::shared_ptr<tonic::DartState> dart_state =
      dispatch_pointer_data_packet_.dart_state().lock();
  if (!dart_state) {
    return;
  }
  tonic::DartState::Scope scope(dart_state);
 
  const std::vector<uint8_t>& buffer = packet.data();
  Dart_Handle data_handle =
      tonic::DartByteData::Create(buffer.data(), buffer.size());
  if (Dart_IsError(data_handle)) {
    return;
  }
 
  tonic::CheckAndHandleError(
      tonic::DartInvoke(dispatch_pointer_data_packet_.Get(), {data_handle}));
}

DispatchSemanticsAction()

void flutter::PlatformConfiguration::DispatchSemanticsAction	(	int32_t	node_id,
		SemanticsAction	action,
		fml::MallocMapping	args
	)

Notifies the framework that the embedder encountered an accessibility related action on the specified node. This call originates on the platform view and has been forwarded to the platform configuration here by the engine.

Parameters

[in]	node_id	The identifier of the accessibility node.
[in]	action	The accessibility related action performed on the node of the specified ID.
[in]	args	Optional data that applies to the specified action.

Definition at line 348 of file platform_configuration.cc.

                                                                           {
  std::shared_ptr<tonic::DartState> dart_state =
      dispatch_semantics_action_.dart_state().lock();
  if (!dart_state) {
    return;
  }
  tonic::DartState::Scope scope(dart_state);
 
  Dart_Handle args_handle =
      (args.GetSize() <= 0) ? Dart_Null() : ToByteData(args);
 
  if (Dart_IsError(args_handle)) {
    return;
  }
 
  tonic::CheckAndHandleError(tonic::DartInvoke(
      dispatch_semantics_action_.Get(),
      {tonic::ToDart(node_id), tonic::ToDart(static_cast<int32_t>(action)),
       args_handle}));
}

GetMetrics()

const ViewportMetrics * flutter::PlatformConfiguration::GetMetrics

(

int

view_id

)

Retrieves the viewport metrics with the given ID managed by the PlatformConfiguration.

Parameters

[in]

view_id

The id of the view's viewport metrics to return.

Returns

a pointer to the ViewportMetrics. Returns nullptr if the ID is not found.

Definition at line 420 of file platform_configuration.cc.

                                                                    {
  auto found = metrics_.find(view_id);
  if (found != metrics_.end()) {
    return &found->second;
  } else {
    return nullptr;
  }
}

on_error()

Dart_Handle flutter::PlatformConfiguration::on_error ( )

inline

Definition at line 517 of file platform_configuration.h.

{ return on_error_.Get(); }

operator=()

PlatformConfiguration & flutter::PlatformConfiguration::operator= ( const PlatformConfiguration &  )

delete

RemoveView()

bool flutter::PlatformConfiguration::RemoveView

(

int64_t

view_id

)

Notify the framework that a view is no longer available.

        Removing a view that does not exist triggers an assertion.

        The implicit view (kFlutterImplicitViewId) should never be
        removed. Doing so triggers an assertion.

Parameters

[in]

view_id

The ID of the view.

Returns

Whether the view was removed.

Definition at line 128 of file platform_configuration.cc.

                                                      {
  if (view_id == kFlutterImplicitViewId) {
    FML_LOG(FATAL) << "The implicit view #" << view_id << " cannot be removed.";
    return false;
  }
  size_t erased_elements = metrics_.erase(view_id);
  if (erased_elements == 0) {
    FML_LOG(ERROR) << "View #" << view_id << " doesn't exist.";
    return false;
  }
 
  std::shared_ptr<tonic::DartState> dart_state =
      remove_view_.dart_state().lock();
  if (!dart_state) {
    return false;
  }
  tonic::DartState::Scope scope(dart_state);
  tonic::CheckAndHandleError(
      tonic::DartInvoke(remove_view_.Get(), {
                                                tonic::ToDart(view_id),
                                            }));
  return true;
}

ReportTimings()

void flutter::PlatformConfiguration::ReportTimings

(

std::vector< int64_t >

timings

)

Dart code cannot fully measure the time it takes for a specific frame to be rendered. This is because Dart code only runs on the UI task runner. That is only a small part of the overall frame workload. The raster task runner frame workload is executed on a thread where Dart code cannot run (and hence instrument). Besides, due to the pipelined nature of rendering in Flutter, there may be multiple frame workloads being processed at any given time. However, for non-Timeline based profiling, it is useful for trace collection and processing to happen in Dart. To do this, the raster task runner frame workloads need to be instrumented separately. After a set number of these profiles have been gathered, they need to be reported back to Dart code. The engine reports this extra instrumentation information back to the framework by invoking this method at predefined intervals.

See also

FrameTiming

Parameters

[in]

timings

Collection of FrameTiming::kStatisticsCount * 'n' values for n frames whose timings have not been reported yet. Many of the values are timestamps, but a collection of integers is reported here for easier conversions to Dart objects. The timestamps are measured against the system monotonic clock measured in microseconds.

Definition at line 393 of file platform_configuration.cc.

                                                                    {
  std::shared_ptr<tonic::DartState> dart_state =
      report_timings_.dart_state().lock();
  if (!dart_state) {
    return;
  }
  tonic::DartState::Scope scope(dart_state);
 
  Dart_Handle data_handle =
      Dart_NewTypedData(Dart_TypedData_kInt64, timings.size());
 
  Dart_TypedData_Type type;
  void* data = nullptr;
  intptr_t num_acquired = 0;
  FML_CHECK(!Dart_IsError(
      Dart_TypedDataAcquireData(data_handle, &type, &data, &num_acquired)));
  FML_DCHECK(num_acquired == static_cast<int>(timings.size()));
 
  memcpy(data, timings.data(), sizeof(int64_t) * timings.size());
  FML_CHECK(Dart_TypedDataReleaseData(data_handle));
 
  tonic::CheckAndHandleError(
      tonic::DartInvoke(report_timings_.Get(), {
                                                   data_handle,
                                               }));
}

UpdateAccessibilityFeatures()

void flutter::PlatformConfiguration::UpdateAccessibilityFeatures

(

int32_t

flags

)

Forward the preference of accessibility features that must be enabled in the semantics tree to the framwork.

Parameters

[in]

flags

The accessibility features that must be generated in the semantics tree.

Definition at line 284 of file platform_configuration.cc.

                                                                      {
  std::shared_ptr<tonic::DartState> dart_state =
      update_accessibility_features_.dart_state().lock();
  if (!dart_state) {
    return;
  }
  tonic::DartState::Scope scope(dart_state);
 
  tonic::CheckAndHandleError(tonic::DartInvoke(
      update_accessibility_features_.Get(), {tonic::ToDart(values)}));
}

UpdateDisplays()

void flutter::PlatformConfiguration::UpdateDisplays

(

const std::vector< DisplayData > &

displays

)

Update the specified display data in the framework.

Parameters

[in]

displays

The display data to send to Dart.

Definition at line 196 of file platform_configuration.cc.

                                            {
  std::vector<DisplayId> ids;
  std::vector<double> widths;
  std::vector<double> heights;
  std::vector<double> device_pixel_ratios;
  std::vector<double> refresh_rates;
  for (const auto& display : displays) {
    ids.push_back(display.id);
    widths.push_back(display.width);
    heights.push_back(display.height);
    device_pixel_ratios.push_back(display.pixel_ratio);
    refresh_rates.push_back(display.refresh_rate);
  }
  std::shared_ptr<tonic::DartState> dart_state =
      update_displays_.dart_state().lock();
  if (!dart_state) {
    return;
  }
  tonic::DartState::Scope scope(dart_state);
  tonic::CheckAndHandleError(tonic::DartInvoke(
      update_displays_.Get(),
      {
          tonic::ToDart<std::vector<DisplayId>>(ids),
          tonic::ToDart<std::vector<double>>(widths),
          tonic::ToDart<std::vector<double>>(heights),
          tonic::ToDart<std::vector<double>>(device_pixel_ratios),
          tonic::ToDart<std::vector<double>>(refresh_rates),
      }));
}

UpdateInitialLifecycleState()

void flutter::PlatformConfiguration::UpdateInitialLifecycleState

(

const std::string &

data

)

Updates the lifecycle state data in the framework.

Parameters

[in]

data

The lifecycle state data.

Definition at line 257 of file platform_configuration.cc.

                           {
  std::shared_ptr<tonic::DartState> dart_state =
      update_initial_lifecycle_state_.dart_state().lock();
  if (!dart_state) {
    return;
  }
  tonic::DartState::Scope scope(dart_state);
  tonic::CheckAndHandleError(tonic::DartInvoke(
      update_initial_lifecycle_state_.Get(), {
                                                 tonic::StdStringToDart(data),
                                             }));
}

UpdateLocales()

void flutter::PlatformConfiguration::UpdateLocales

(

const std::vector< std::string > &

locales

)

Update the specified locale data in the framework.

Parameters

[in]

locale_data

The locale data. This should consist of groups of 4 strings, each group representing a single locale.

Definition at line 227 of file platform_configuration.cc.

                                         {
  std::shared_ptr<tonic::DartState> dart_state =
      update_locales_.dart_state().lock();
  if (!dart_state) {
    return;
  }
 
  tonic::DartState::Scope scope(dart_state);
  tonic::CheckAndHandleError(
      tonic::DartInvoke(update_locales_.Get(),
                        {
                            tonic::ToDart<std::vector<std::string>>(locales),
                        }));
}

UpdateSemanticsEnabled()

void flutter::PlatformConfiguration::UpdateSemanticsEnabled

(

bool

enabled

)

Notifies the PlatformConfiguration that the embedder has expressed an opinion about whether the accessibility tree should be generated or not. This call originates in the platform view and is forwarded to the PlatformConfiguration here by the engine.

Parameters

[in]

enabled

Whether the accessibility tree is enabled or disabled.

Definition at line 271 of file platform_configuration.cc.

                                                               {
  std::shared_ptr<tonic::DartState> dart_state =
      update_semantics_enabled_.dart_state().lock();
  if (!dart_state) {
    return;
  }
  tonic::DartState::Scope scope(dart_state);
  UIDartState::ThrowIfUIOperationsProhibited();
 
  tonic::CheckAndHandleError(tonic::DartInvoke(update_semantics_enabled_.Get(),
                                               {tonic::ToDart(enabled)}));
}

UpdateUserSettingsData()

void flutter::PlatformConfiguration::UpdateUserSettingsData

(

const std::string &

data

)

Update the user settings data in the framework.

Parameters

[in]

data

The user settings data.

Definition at line 243 of file platform_configuration.cc.

                                                                        {
  std::shared_ptr<tonic::DartState> dart_state =
      update_user_settings_data_.dart_state().lock();
  if (!dart_state) {
    return;
  }
  tonic::DartState::Scope scope(dart_state);
 
  tonic::CheckAndHandleError(tonic::DartInvoke(update_user_settings_data_.Get(),
                                               {
                                                   tonic::StdStringToDart(data),
                                               }));
}

UpdateViewMetrics()

bool flutter::PlatformConfiguration::UpdateViewMetrics	(	int64_t	view_id,
		const ViewportMetrics &	metrics
	)

Update the view metrics for the specified view.

        If the view is not found, silently return false.

Parameters

[in]	view_id	The ID of the view.
[in]	metrics	The new metrics of the view.

Returns

Whether the view is found.

Definition at line 152 of file platform_configuration.cc.

                                         {
  auto found_iter = metrics_.find(view_id);
  if (found_iter == metrics_.end()) {
    return false;
  }
 
  found_iter->second = view_metrics;
 
  std::shared_ptr<tonic::DartState> dart_state =
      update_window_metrics_.dart_state().lock();
  if (!dart_state) {
    return false;
  }
  tonic::DartState::Scope scope(dart_state);
  tonic::CheckAndHandleError(tonic::DartInvoke(
      update_window_metrics_.Get(),
      {
          tonic::ToDart(view_id),
          tonic::ToDart(view_metrics.device_pixel_ratio),
          tonic::ToDart(view_metrics.physical_width),
          tonic::ToDart(view_metrics.physical_height),
          tonic::ToDart(view_metrics.physical_padding_top),
          tonic::ToDart(view_metrics.physical_padding_right),
          tonic::ToDart(view_metrics.physical_padding_bottom),
          tonic::ToDart(view_metrics.physical_padding_left),
          tonic::ToDart(view_metrics.physical_view_inset_top),
          tonic::ToDart(view_metrics.physical_view_inset_right),
          tonic::ToDart(view_metrics.physical_view_inset_bottom),
          tonic::ToDart(view_metrics.physical_view_inset_left),
          tonic::ToDart(view_metrics.physical_system_gesture_inset_top),
          tonic::ToDart(view_metrics.physical_system_gesture_inset_right),
          tonic::ToDart(view_metrics.physical_system_gesture_inset_bottom),
          tonic::ToDart(view_metrics.physical_system_gesture_inset_left),
          tonic::ToDart(view_metrics.physical_touch_slop),
          tonic::ToDart(view_metrics.physical_display_features_bounds),
          tonic::ToDart(view_metrics.physical_display_features_type),
          tonic::ToDart(view_metrics.physical_display_features_state),
          tonic::ToDart(view_metrics.display_id),
      }));
  return true;
}

---

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

• lib/ui/window/platform_configuration.h
• lib/ui/window/platform_configuration.cc