blob: d3d56c13f1029d0ceb59ff07d98a020d1f954df6 [file] [log] [blame]
// Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "flutter/lib/ui/window/platform_configuration.h"
#include <cstring>
#include "flutter/lib/ui/compositing/scene.h"
#include "flutter/lib/ui/ui_dart_state.h"
#include "flutter/lib/ui/window/platform_message_response_dart.h"
#include "flutter/lib/ui/window/platform_message_response_dart_port.h"
#include "flutter/lib/ui/window/viewport_metrics.h"
#include "flutter/lib/ui/window/window.h"
#include "third_party/tonic/converter/dart_converter.h"
#include "third_party/tonic/dart_args.h"
#include "third_party/tonic/dart_library_natives.h"
#include "third_party/tonic/dart_microtask_queue.h"
#include "third_party/tonic/logging/dart_invoke.h"
#include "third_party/tonic/typed_data/dart_byte_data.h"
namespace flutter {
namespace {
Dart_Handle ToByteData(const fml::Mapping& buffer) {
return tonic::DartByteData::Create(buffer.GetMapping(), buffer.GetSize());
}
} // namespace
PlatformConfigurationClient::~PlatformConfigurationClient() {}
PlatformConfiguration::PlatformConfiguration(
PlatformConfigurationClient* client)
: client_(client) {}
PlatformConfiguration::~PlatformConfiguration() {}
void PlatformConfiguration::DidCreateIsolate() {
Dart_Handle library = Dart_LookupLibrary(tonic::ToDart("dart:ui"));
on_error_.Set(tonic::DartState::Current(),
Dart_GetField(library, tonic::ToDart("_onError")));
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_lifecycle_state_.Set(
tonic::DartState::Current(),
Dart_GetField(library, tonic::ToDart("_updateLifecycleState")));
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_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")));
windows_.insert(std::make_pair(
0, std::make_unique<Window>(0, ViewportMetrics{1.0, 0.0, 0.0, -1})));
}
void PlatformConfiguration::UpdateLocales(
const std::vector<std::string>& locales) {
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),
}));
}
void PlatformConfiguration::UpdateUserSettingsData(const std::string& data) {
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),
}));
}
void PlatformConfiguration::UpdateLifecycleState(const std::string& data) {
std::shared_ptr<tonic::DartState> dart_state =
update_lifecycle_state_.dart_state().lock();
if (!dart_state) {
return;
}
tonic::DartState::Scope scope(dart_state);
tonic::CheckAndHandleError(tonic::DartInvoke(update_lifecycle_state_.Get(),
{
tonic::StdStringToDart(data),
}));
}
void PlatformConfiguration::UpdateSemanticsEnabled(bool enabled) {
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)}));
}
void PlatformConfiguration::UpdateAccessibilityFeatures(int32_t values) {
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)}));
}
void PlatformConfiguration::DispatchPlatformMessage(
std::unique_ptr<PlatformMessage> message) {
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)}));
}
void PlatformConfiguration::DispatchSemanticsAction(int32_t id,
SemanticsAction action,
fml::MallocMapping args) {
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(id), tonic::ToDart(static_cast<int32_t>(action)),
args_handle}));
}
void PlatformConfiguration::BeginFrame(fml::TimePoint frameTime,
uint64_t frame_number) {
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()));
}
void PlatformConfiguration::ReportTimings(std::vector<int64_t> timings) {
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,
}));
}
void PlatformConfiguration::CompletePlatformMessageEmptyResponse(
int response_id) {
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();
}
void PlatformConfiguration::CompletePlatformMessageResponse(
int response_id,
std::vector<uint8_t> data) {
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)));
}
void PlatformConfigurationNativeApi::Render(Scene* scene) {
UIDartState::ThrowIfUIOperationsProhibited();
UIDartState::Current()->platform_configuration()->client()->Render(scene);
}
void PlatformConfigurationNativeApi::SetNeedsReportTimings(bool value) {
UIDartState::ThrowIfUIOperationsProhibited();
UIDartState::Current()
->platform_configuration()
->client()
->SetNeedsReportTimings(value);
}
namespace {
Dart_Handle HandlePlatformMessage(
UIDartState* dart_state,
const std::string& name,
Dart_Handle data_handle,
const fml::RefPtr<PlatformMessageResponse>& response) {
if (Dart_IsNull(data_handle)) {
return dart_state->HandlePlatformMessage(
std::make_unique<PlatformMessage>(name, response));
} else {
tonic::DartByteData data(data_handle);
const uint8_t* buffer = static_cast<const uint8_t*>(data.data());
return dart_state->HandlePlatformMessage(std::make_unique<PlatformMessage>(
name, fml::MallocMapping::Copy(buffer, data.length_in_bytes()),
response));
}
}
} // namespace
Dart_Handle PlatformConfigurationNativeApi::SendPlatformMessage(
const std::string& name,
Dart_Handle callback,
Dart_Handle data_handle) {
UIDartState* dart_state = UIDartState::Current();
if (!dart_state->platform_configuration()) {
return tonic::ToDart(
"SendPlatformMessage only works on the root isolate, see "
"SendPortPlatformMessage.");
}
fml::RefPtr<PlatformMessageResponse> response;
if (!Dart_IsNull(callback)) {
response = fml::MakeRefCounted<PlatformMessageResponseDart>(
tonic::DartPersistentValue(dart_state, callback),
dart_state->GetTaskRunners().GetUITaskRunner(), name);
}
return HandlePlatformMessage(dart_state, name, data_handle, response);
}
Dart_Handle PlatformConfigurationNativeApi::SendPortPlatformMessage(
const std::string& name,
Dart_Handle identifier,
Dart_Handle send_port,
Dart_Handle data_handle) {
// This can be executed on any isolate.
UIDartState* dart_state = UIDartState::Current();
int64_t c_send_port = tonic::DartConverter<int64_t>::FromDart(send_port);
if (c_send_port == ILLEGAL_PORT) {
return tonic::ToDart("Invalid port specified");
}
fml::RefPtr<PlatformMessageResponse> response =
fml::MakeRefCounted<PlatformMessageResponseDartPort>(
c_send_port, tonic::DartConverter<int64_t>::FromDart(identifier),
name);
return HandlePlatformMessage(dart_state, name, data_handle, response);
}
void PlatformConfigurationNativeApi::RespondToPlatformMessage(
int response_id,
const tonic::DartByteData& data) {
if (Dart_IsNull(data.dart_handle())) {
UIDartState::Current()
->platform_configuration()
->CompletePlatformMessageEmptyResponse(response_id);
} else {
// TODO(engine): Avoid this copy.
const uint8_t* buffer = static_cast<const uint8_t*>(data.data());
UIDartState::Current()
->platform_configuration()
->CompletePlatformMessageResponse(
response_id,
std::vector<uint8_t>(buffer, buffer + data.length_in_bytes()));
}
}
void PlatformConfigurationNativeApi::SetIsolateDebugName(
const std::string& name) {
UIDartState::ThrowIfUIOperationsProhibited();
UIDartState::Current()->SetDebugName(name);
}
Dart_PerformanceMode PlatformConfigurationNativeApi::current_performace_mode_ =
Dart_PerformanceMode_Default;
Dart_PerformanceMode PlatformConfigurationNativeApi::GetDartPerformanceMode() {
return current_performace_mode_;
}
int PlatformConfigurationNativeApi::RequestDartPerformanceMode(int mode) {
UIDartState::ThrowIfUIOperationsProhibited();
current_performace_mode_ = static_cast<Dart_PerformanceMode>(mode);
return Dart_SetPerformanceMode(current_performace_mode_);
}
Dart_Handle PlatformConfigurationNativeApi::GetPersistentIsolateData() {
UIDartState::ThrowIfUIOperationsProhibited();
auto persistent_isolate_data = UIDartState::Current()
->platform_configuration()
->client()
->GetPersistentIsolateData();
if (!persistent_isolate_data) {
return Dart_Null();
}
return tonic::DartByteData::Create(persistent_isolate_data->GetMapping(),
persistent_isolate_data->GetSize());
}
void PlatformConfigurationNativeApi::ScheduleFrame() {
UIDartState::ThrowIfUIOperationsProhibited();
UIDartState::Current()->platform_configuration()->client()->ScheduleFrame();
}
void PlatformConfigurationNativeApi::UpdateSemantics(SemanticsUpdate* update) {
UIDartState::ThrowIfUIOperationsProhibited();
UIDartState::Current()->platform_configuration()->client()->UpdateSemantics(
update);
}
Dart_Handle PlatformConfigurationNativeApi::ComputePlatformResolvedLocale(
Dart_Handle supportedLocalesHandle) {
UIDartState::ThrowIfUIOperationsProhibited();
std::vector<std::string> supportedLocales =
tonic::DartConverter<std::vector<std::string>>::FromDart(
supportedLocalesHandle);
std::vector<std::string> results =
*UIDartState::Current()
->platform_configuration()
->client()
->ComputePlatformResolvedLocale(supportedLocales);
return tonic::DartConverter<std::vector<std::string>>::ToDart(results);
}
std::string PlatformConfigurationNativeApi::DefaultRouteName() {
UIDartState::ThrowIfUIOperationsProhibited();
return UIDartState::Current()
->platform_configuration()
->client()
->DefaultRouteName();
}
int64_t PlatformConfigurationNativeApi::GetRootIsolateToken() {
UIDartState* dart_state = UIDartState::Current();
FML_DCHECK(dart_state);
return dart_state->GetRootIsolateToken();
}
void PlatformConfigurationNativeApi::RegisterBackgroundIsolate(
int64_t root_isolate_token) {
UIDartState* dart_state = UIDartState::Current();
FML_DCHECK(dart_state && !dart_state->IsRootIsolate());
auto platform_message_handler =
(*static_cast<std::shared_ptr<PlatformMessageHandlerStorage>*>(
Dart_CurrentIsolateGroupData()));
FML_DCHECK(platform_message_handler);
auto weak_platform_message_handler =
platform_message_handler->GetPlatformMessageHandler(root_isolate_token);
dart_state->SetPlatformMessageHandler(weak_platform_message_handler);
}
} // namespace flutter