5#include "flutter/runtime/dart_isolate.h"
11#include "flutter/fml/logging.h"
12#include "flutter/fml/posix_wrappers.h"
13#include "flutter/fml/trace_event.h"
14#include "flutter/lib/io/dart_io.h"
15#include "flutter/lib/ui/dart_runtime_hooks.h"
16#include "flutter/lib/ui/dart_ui.h"
17#include "flutter/lib/ui/window/platform_isolate.h"
18#include "flutter/runtime/dart_isolate_group_data.h"
19#include "flutter/runtime/dart_plugin_registrant.h"
20#include "flutter/runtime/dart_service_isolate.h"
21#include "flutter/runtime/dart_vm.h"
22#include "flutter/runtime/dart_vm_lifecycle.h"
23#include "flutter/runtime/isolate_configuration.h"
24#include "flutter/runtime/runtime_controller.h"
28#include "third_party/dart/runtime/include/dart_api.h"
29#include "third_party/dart/runtime/include/dart_tools_api.h"
46class DartErrorString {
54 char**
error() {
return &str_; }
55 const char* str()
const {
return str_; }
56 explicit operator bool()
const {
return str_ !=
nullptr; }
65DartIsolate::Flags::Flags() :
Flags(nullptr) {}
75DartIsolate::Flags::~Flags() =
default;
77void DartIsolate::Flags::SetNullSafetyEnabled(
bool enabled) {
78 flags_.null_safety = enabled;
81void DartIsolate::Flags::SetIsDontNeedSafe(
bool value) {
82 flags_.snapshot_is_dontneed_safe =
value;
97 std::optional<std::string> dart_entrypoint,
98 std::optional<std::string> dart_entrypoint_library,
99 const std::vector<std::string>& dart_entrypoint_args,
100 std::unique_ptr<IsolateConfiguration> isolate_configuration,
103 if (!isolate_snapshot) {
108 if (!isolate_configuration) {
114 isolate_configuration->IsNullSafetyEnabled(*isolate_snapshot));
117 auto isolate = CreateRootIsolate(settings,
121 isolate_create_callback,
122 isolate_shutdown_callback,
135 FML_DLOG(ERROR) <<
"Could not shutdown transient isolate.";
140 FML_LOG(
ERROR) <<
"Root isolate was created in an incorrect phase: "
141 <<
static_cast<int>(
isolate->GetPhase());
145 if (!isolate_configuration->PrepareIsolate(*
isolate.get())) {
151 FML_LOG(
ERROR) <<
"Root isolate not in the ready phase for Dart entrypoint "
156 if (settings.root_isolate_create_callback) {
160 settings.root_isolate_create_callback(*
isolate.get());
163 if (root_isolate_create_callback) {
164 root_isolate_create_callback();
167 if (!
isolate->RunFromLibrary(std::move(dart_entrypoint_library),
168 std::move(dart_entrypoint),
169 dart_entrypoint_args)) {
170 FML_LOG(
ERROR) <<
"Could not run the run main Dart entrypoint.";
174 if (settings.root_isolate_shutdown_callback) {
175 isolate->AddIsolateShutdownCallback(
176 settings.root_isolate_shutdown_callback);
179 shutdown_on_error.Release();
184void DartIsolate::SpawnIsolateShutdownCallback(
185 std::shared_ptr<DartIsolateGroupData>* isolate_group_data,
186 std::shared_ptr<DartIsolate>* isolate_data) {
187 DartIsolate::DartIsolateShutdownCallback(isolate_group_data, isolate_data);
190std::weak_ptr<DartIsolate> DartIsolate::CreateRootIsolate(
191 const Settings& settings,
197 const UIDartState::Context& context,
198 const DartIsolate* spawning_isolate) {
199 TRACE_EVENT0(
"flutter",
"DartIsolate::CreateRootIsolate");
202 std::unique_ptr<std::shared_ptr<DartIsolateGroupData>> isolate_group_data;
204 auto isolate_data = std::make_unique<std::shared_ptr<DartIsolate>>(
205 std::shared_ptr<DartIsolate>(
new DartIsolate(
209 !!spawning_isolate)));
211 DartErrorString
error;
213 auto isolate_flags =
flags.Get();
215 IsolateMaker isolate_maker;
216 if (spawning_isolate) {
219 std::shared_ptr<DartIsolateGroupData>* isolate_group_data,
220 std::shared_ptr<DartIsolate>* isolate_data,
223 spawning_isolate->isolate(),
225 spawning_isolate->GetIsolateGroupData()
226 .GetAdvisoryScriptEntrypoint()
230 DartIsolate::SpawnIsolateShutdownCallback),
233 DartIsolateCleanupCallback),
241 std::make_unique<std::shared_ptr<DartIsolateGroupData>>(
242 std::shared_ptr<DartIsolateGroupData>(
new DartIsolateGroupData(
244 std::move(isolate_snapshot),
245 context.advisory_script_uri,
246 context.advisory_script_entrypoint,
248 isolate_create_callback,
249 isolate_shutdown_callback
251 isolate_maker = [](std::shared_ptr<DartIsolateGroupData>*
253 std::shared_ptr<DartIsolate>* isolate_data,
256 (*isolate_group_data)->GetAdvisoryScriptURI().c_str(),
257 (*isolate_group_data)->GetAdvisoryScriptEntrypoint().c_str(),
258 (*isolate_group_data)->GetIsolateSnapshot()->GetDataMapping(),
259 (*isolate_group_data)->GetIsolateSnapshot()->GetInstructionsMapping(),
260 flags, isolate_group_data, isolate_data,
error);
264 vm_isolate = CreateDartIsolateGroup(std::move(isolate_group_data),
265 std::move(isolate_data), &isolate_flags,
266 error.error(), isolate_maker);
272 if (vm_isolate ==
nullptr) {
276 std::shared_ptr<DartIsolate>* root_isolate_data =
282 return (*root_isolate_data)->GetWeakIsolatePtr();
290 std::shared_ptr<PlatformIsolateManager> platform_isolate_manager =
292 std::weak_ptr<PlatformIsolateManager> weak_platform_isolate_manager =
293 platform_isolate_manager;
294 if (platform_isolate_manager->HasShutdownMaybeFalseNegative()) {
297 FML_LOG(INFO) <<
"CreatePlatformIsolate called after shutdown";
309 auto isolate_group_data = std::shared_ptr<DartIsolateGroupData>(
310 *
static_cast<std::shared_ptr<DartIsolateGroupData>*
>(
313 Settings settings(isolate_group_data->GetSettings());
320 settings.unhandled_exception_callback = [](
const std::string&
error,
321 const std::string& stack_trace) {
329 settings.task_observer_add = [old_task_observer_add, platform_task_runner,
330 weak_platform_isolate_manager](
332 platform_task_runner->PostTask([old_task_observer_add,
333 weak_platform_isolate_manager,
key,
335 std::shared_ptr<PlatformIsolateManager> platform_isolate_manager =
336 weak_platform_isolate_manager.lock();
337 if (platform_isolate_manager ==
nullptr ||
338 platform_isolate_manager->HasShutdown()) {
341 FML_LOG(INFO) <<
"Shutdown before platform isolate task observer added";
351 isolate_group_data->GetAdvisoryScriptEntrypoint();
352 auto isolate_data = std::make_unique<std::shared_ptr<DartIsolate>>(
353 std::shared_ptr<DartIsolate>(
354 new DartIsolate(settings, context, platform_isolate_manager)));
356 IsolateMaker isolate_maker =
358 std::shared_ptr<DartIsolateGroupData>* unused_isolate_group_data,
366 DartIsolate::SpawnIsolateShutdownCallback),
369 DartIsolateCleanupCallback),
374 nullptr, std::move(isolate_data),
nullptr,
error, isolate_maker);
382 if (!platform_isolate_manager->RegisterPlatformIsolate(platform_isolate)) {
386 FML_LOG(INFO) <<
"Shutdown during platform isolate creation";
396 platform_task_runner->PostTask([entry_point_handle, platform_isolate,
397 weak_platform_isolate_manager]() {
398 std::shared_ptr<PlatformIsolateManager> platform_isolate_manager =
399 weak_platform_isolate_manager.lock();
400 if (platform_isolate_manager ==
nullptr ||
401 platform_isolate_manager->HasShutdown()) {
404 FML_LOG(INFO) <<
"Shutdown before platform isolate entry point";
426 return platform_isolate;
429DartIsolate::DartIsolate(
const Settings& settings,
430 bool is_root_isolate,
432 bool is_spawning_in_group)
434 settings.task_observer_remove,
437 settings.log_message_callback,
441 may_insecurely_connect_to_all_domains_(
442 settings.may_insecurely_connect_to_all_domains),
443 is_platform_isolate_(false),
444 is_spawning_in_group_(is_spawning_in_group),
445 domain_network_policy_(settings.domain_network_policy) {
449DartIsolate::DartIsolate(
450 const Settings& settings,
451 const UIDartState::Context& context,
452 std::shared_ptr<PlatformIsolateManager> platform_isolate_manager)
453 : UIDartState(settings.task_observer_add,
454 settings.task_observer_remove,
456 settings.unhandled_exception_callback,
457 settings.log_message_callback,
458 DartVMRef::GetIsolateNameServer(),
461 may_insecurely_connect_to_all_domains_(
462 settings.may_insecurely_connect_to_all_domains),
463 is_platform_isolate_(
true),
464 is_spawning_in_group_(false),
465 domain_network_policy_(settings.domain_network_policy),
466 platform_isolate_manager_(
std::move(platform_isolate_manager)) {
482 std::string service_id(service_id_buf);
483 free(
const_cast<char*
>(service_id_buf));
487bool DartIsolate::Initialize(
Dart_Isolate dart_isolate) {
507 if (is_platform_isolate_) {
508 SetMessageHandlingTaskRunner(
GetTaskRunners().GetPlatformTaskRunner(),
511 SetMessageHandlingTaskRunner(
GetTaskRunners().GetUITaskRunner(),
false);
524 if (!UpdateThreadPoolNames()) {
533 return message_handling_task_runner_;
537 intptr_t loading_unit_id,
538 std::unique_ptr<const fml::Mapping> snapshot_data,
539 std::unique_ptr<const fml::Mapping> snapshot_instructions) {
544 std::move(snapshot_data), std::move(snapshot_instructions));
547 loading_unit_id, dart_snapshot->GetDataMapping(),
548 dart_snapshot->GetInstructionsMapping());
554 loading_unit_snapshots_.insert(dart_snapshot);
559 const std::string& error_message,
563 loading_unit_id, error_message.c_str(), transient);
567void DartIsolate::SetMessageHandlingTaskRunner(
569 bool post_directly_to_runner) {
574 message_handling_task_runner_ = runner;
579 post_directly_to_runner =
true;
582 if (post_directly_to_runner) {
583 dispatcher = [runner](std::function<void()> task) {
584 runner->PostTask([task = std::move(task)]() {
590 dispatcher = [runner](std::function<void()> task) {
592 task_queues->RegisterTask(
593 runner->GetTaskQueueId(),
594 [task = std::move(task)]() {
595 TRACE_EVENT0(
"flutter",
"DartIsolate::HandleMessage");
608bool DartIsolate::UpdateThreadPoolNames()
const {
613 if (
auto task_runner = task_runners.GetRasterTaskRunner()) {
614 task_runner->PostTask(
615 [label = task_runners.GetLabel() + std::string{
".raster"}]() {
616 Dart_SetThreadName(label.c_str());
620 if (
auto task_runner = task_runners.GetUITaskRunner()) {
621 task_runner->PostTask(
622 [label = task_runners.GetLabel() + std::string{
".ui"}]() {
623 Dart_SetThreadName(label.c_str());
627 if (
auto task_runner = task_runners.GetIOTaskRunner()) {
628 task_runner->PostTask(
629 [label = task_runners.GetLabel() + std::string{
".io"}]() {
630 Dart_SetThreadName(label.c_str());
634 if (
auto task_runner = task_runners.GetPlatformTaskRunner()) {
635 task_runner->PostTask(
636 [label = task_runners.GetLabel() + std::string{
".platform"}]() {
637 Dart_SetThreadName(label.c_str());
644bool DartIsolate::LoadLibraries() {
653 domain_network_policy_);
662 if (!is_service_isolate) {
664 "ui", std::make_unique<tonic::DartClassProvider>(
this,
"dart:ui"));
672 TRACE_EVENT0(
"flutter",
"DartIsolate::PrepareForRunningFromPrecompiledCode");
683 if (!MarkIsolateRunnable()) {
689 return isolate->PrepareForRunningFromPrecompiledCode();
695 if (isolate_create_callback) {
696 isolate_create_callback();
703bool DartIsolate::LoadKernel(
const std::shared_ptr<const fml::Mapping>& mapping,
705 if (!
Dart_IsKernel(mapping->GetMapping(), mapping->GetSize())) {
731 const std::shared_ptr<const fml::Mapping>& mapping,
734 TRACE_EVENT0(
"flutter",
"DartIsolate::PrepareForRunningFromKernel");
745 if (!child_isolate && !is_spawning_in_group_) {
746 if (!mapping || mapping->GetSize() == 0) {
753 if (!LoadKernel(mapping, last_piece)) {
767 if (!MarkIsolateRunnable()) {
778 for (uint64_t i = 0; i < buffers.size(); i++) {
779 bool last_piece = i + 1 == buffers.size();
780 const std::shared_ptr<const fml::Mapping>&
buffer = buffers.at(i);
793 if (isolate_create_callback) {
794 isolate_create_callback();
803 std::vector<std::shared_ptr<const fml::Mapping>> kernels) {
804 const auto count = kernels.size();
809 for (
size_t i = 0; i <
count; ++i) {
810 bool last = (i == (
count - 1));
821 std::vector<std::unique_ptr<const fml::Mapping>> kernels) {
822 std::vector<std::shared_ptr<const fml::Mapping>> shared_kernels;
823 shared_kernels.reserve(kernels.size());
824 for (
auto& kernel : kernels) {
825 shared_kernels.emplace_back(std::move(kernel));
830bool DartIsolate::MarkIsolateRunnable() {
831 TRACE_EVENT0(
"flutter",
"DartIsolate::MarkIsolateRunnable");
861 FML_LOG(
ERROR) <<
"Could not resolve main entrypoint function.";
867 "_getStartMainIsolateFunction", {});
870 FML_LOG(
ERROR) <<
"Could not resolve main entrypoint trampoline.";
876 {start_main_isolate_function, user_entrypoint_function,
args}))) {
877 FML_LOG(
ERROR) <<
"Could not invoke the main entrypoint.";
885 std::optional<std::string> entrypoint,
886 const std::vector<std::string>&
args) {
894 auto library_handle =
895 library_name.has_value() && !library_name.value().empty()
898 auto entrypoint_handle = entrypoint.has_value() && !entrypoint.value().empty()
909 auto user_entrypoint_function =
935 if (vm_isolate !=
nullptr) {
946Dart_Isolate DartIsolate::DartCreateAndStartServiceIsolate(
947 const char* package_root,
948 const char* package_config,
955 "Could not access VM data to initialize isolates. This may be because "
956 "the VM has initialized shutdown on another thread already.");
960 const auto& settings = vm_data->GetSettings();
962 if (!settings.enable_vm_service) {
966 flags->load_vmservice_library =
true;
968#if (FLUTTER_RUNTIME_MODE != FLUTTER_RUNTIME_MODE_DEBUG)
972 flags->null_safety = vm_data->GetServiceIsolateSnapshotNullSafety();
975 UIDartState::Context context(
980 std::weak_ptr<DartIsolate> weak_service_isolate =
981 DartIsolate::CreateRootIsolate(vm_data->GetSettings(),
982 vm_data->GetServiceIsolateSnapshot(),
984 DartIsolate::Flags{flags},
989 std::shared_ptr<DartIsolate> service_isolate = weak_service_isolate.lock();
990 if (!service_isolate) {
1002 settings.disable_service_auth_codes,
1003 settings.enable_service_port_fallback,
1012 if (
auto callback = vm_data->GetSettings().service_isolate_create_callback) {
1017 service_protocol->ToggleHooks(
true);
1020 <<
"Could not acquire the service protocol handlers. This might be "
1021 "because the VM has already begun teardown on another thread.";
1024 return service_isolate->isolate();
1028 std::shared_ptr<DartIsolateGroupData>* isolate_group_data =
1029 static_cast<std::shared_ptr<DartIsolateGroupData>*
>(
1031 return **isolate_group_data;
1040Dart_Isolate DartIsolate::DartIsolateGroupCreateCallback(
1041 const char* advisory_script_uri,
1042 const char* advisory_script_entrypoint,
1043 const char* package_root,
1044 const char* package_config,
1046 std::shared_ptr<DartIsolate>* parent_isolate_data,
1048 TRACE_EVENT0(
"flutter",
"DartIsolate::DartIsolateGroupCreateCallback");
1049 if (parent_isolate_data ==
nullptr &&
1056 return DartCreateAndStartServiceIsolate(package_root,
1063 if (!parent_isolate_data) {
1067 DartIsolateGroupData& parent_group_data =
1068 (*parent_isolate_data)->GetIsolateGroupData();
1072 std::string error_msg =
1073 std::string(
"Unsupported isolate URI: ") + advisory_script_uri;
1078 auto isolate_group_data =
1079 std::make_unique<std::shared_ptr<DartIsolateGroupData>>(
1080 std::shared_ptr<DartIsolateGroupData>(
new DartIsolateGroupData(
1081 parent_group_data.GetSettings(),
1082 parent_group_data.GetIsolateSnapshot(), advisory_script_uri,
1083 advisory_script_entrypoint,
1084 parent_group_data.GetChildIsolatePreparer(),
1085 parent_group_data.GetIsolateCreateCallback(),
1086 parent_group_data.GetIsolateShutdownCallback())));
1088 TaskRunners null_task_runners(advisory_script_uri,
1094 UIDartState::Context context(null_task_runners);
1095 context.advisory_script_uri = advisory_script_uri;
1096 context.advisory_script_entrypoint = advisory_script_entrypoint;
1097 auto isolate_data = std::make_unique<std::shared_ptr<DartIsolate>>(
1098 std::shared_ptr<DartIsolate>(
1099 new DartIsolate((*isolate_group_data)->GetSettings(),
1104 std::move(isolate_group_data), std::move(isolate_data),
flags,
error,
1105 [](std::shared_ptr<DartIsolateGroupData>* isolate_group_data,
1109 (*isolate_group_data)->GetAdvisoryScriptURI().c_str(),
1110 (*isolate_group_data)->GetAdvisoryScriptEntrypoint().c_str(),
1111 (*isolate_group_data)->GetIsolateSnapshot()->GetDataMapping(),
1112 (*isolate_group_data)
1113 ->GetIsolateSnapshot()
1114 ->GetInstructionsMapping(),
1115 flags, isolate_group_data, isolate_data,
error);
1126bool DartIsolate::DartIsolateInitializeCallback(
void** child_callback_data,
1128 TRACE_EVENT0(
"flutter",
"DartIsolate::DartIsolateInitializeCallback");
1131 *
error =
fml::strdup(
"Isolate should be available in initialize callback.");
1136 auto* isolate_group_data =
1137 static_cast<std::shared_ptr<DartIsolateGroupData>*
>(
1140 TaskRunners null_task_runners((*isolate_group_data)->GetAdvisoryScriptURI(),
1146 UIDartState::Context context(null_task_runners);
1147 context.advisory_script_uri = (*isolate_group_data)->GetAdvisoryScriptURI();
1148 context.advisory_script_entrypoint =
1149 (*isolate_group_data)->GetAdvisoryScriptEntrypoint();
1150 auto embedder_isolate = std::make_unique<std::shared_ptr<DartIsolate>>(
1151 std::shared_ptr<DartIsolate>(
1152 new DartIsolate((*isolate_group_data)->GetSettings(),
1157 if (!InitializeIsolate(*embedder_isolate,
isolate,
error)) {
1163 *child_callback_data = embedder_isolate.release();
1169 std::unique_ptr<std::shared_ptr<DartIsolateGroupData>> isolate_group_data,
1170 std::unique_ptr<std::shared_ptr<DartIsolate>> isolate_data,
1173 const DartIsolate::IsolateMaker& make_isolate) {
1174 TRACE_EVENT0(
"flutter",
"DartIsolate::CreateDartIsolateGroup");
1178 make_isolate(isolate_group_data.get(), isolate_data.get(),
flags,
error);
1184 bool success =
false;
1189 std::shared_ptr<DartIsolate> embedder_isolate(*isolate_data);
1190 isolate_group_data.release();
1191 isolate_data.release();
1194 success = InitializeIsolate(embedder_isolate,
isolate,
error);
1206bool DartIsolate::InitializeIsolate(
1207 const std::shared_ptr<DartIsolate>& embedder_isolate,
1210 TRACE_EVENT0(
"flutter",
"DartIsolate::InitializeIsolate");
1211 if (!embedder_isolate->Initialize(
isolate)) {
1217 if (!embedder_isolate->LoadLibraries()) {
1219 "Embedder could not load libraries in the new Dart isolate.");
1228 if (!embedder_isolate->IsRootIsolate()) {
1229 auto child_isolate_preparer =
1230 embedder_isolate->GetIsolateGroupData().GetChildIsolatePreparer();
1232 if (!child_isolate_preparer(embedder_isolate.get())) {
1243void DartIsolate::DartIsolateShutdownCallback(
1244 std::shared_ptr<DartIsolateGroupData>* isolate_group_data,
1245 std::shared_ptr<DartIsolate>* isolate_data) {
1246 TRACE_EVENT0(
"flutter",
"DartIsolate::DartIsolateShutdownCallback");
1251 if (isolate_data ==
nullptr) {
1255 isolate_data->get()->OnShutdownCallback();
1259void DartIsolate::DartIsolateGroupCleanupCallback(
1260 std::shared_ptr<DartIsolateGroupData>* isolate_data) {
1261 TRACE_EVENT0(
"flutter",
"DartIsolate::DartIsolateGroupCleanupCallback");
1262 delete isolate_data;
1266void DartIsolate::DartIsolateCleanupCallback(
1267 std::shared_ptr<DartIsolateGroupData>* isolate_group_data,
1268 std::shared_ptr<DartIsolate>* isolate_data) {
1269 TRACE_EVENT0(
"flutter",
"DartIsolate::DartIsolateCleanupCallback");
1270 delete isolate_data;
1274 return std::static_pointer_cast<DartIsolate>(shared_from_this());
1278 shutdown_callbacks_.emplace_back(std::make_unique<AutoFireClosure>(closure));
1281void DartIsolate::OnShutdownCallback() {
1283 if (
state !=
nullptr) {
1284 state->SetIsShuttingDown();
1295 if (is_platform_isolate_) {
1296 FML_DCHECK(platform_isolate_manager_ !=
nullptr);
1297 platform_isolate_manager_->RemovePlatformIsolate(
isolate());
1300 shutdown_callbacks_.clear();
1304 if (isolate_shutdown_callback) {
1305 isolate_shutdown_callback();
1309Dart_Handle DartIsolate::OnDartLoadLibrary(intptr_t loading_unit_id) {
1315 const std::string error_message =
1316 "Platform Configuration was null. Deferred library load request "
1317 "for loading unit id " +
1318 std::to_string(loading_unit_id) +
" was not sent.";
1324 const std::shared_ptr<const fml::Mapping>& mapping) {
1329 auto* isolate_group_data =
1330 static_cast<std::shared_ptr<DartIsolateGroupData>*
>(
1333 (*isolate_group_data)->AddKernelBuffer(mapping);
1347DartIsolate::AutoFireClosure::AutoFireClosure(
const fml::closure& closure)
1348 : closure_(closure) {}
1350DartIsolate::AutoFireClosure::~AutoFireClosure() {
static void InitForIsolate(bool may_insecurely_connect_to_all_domains, const std::string &domain_network_policy)
const fml::closure & GetIsolateShutdownCallback() const
void SetChildIsolatePreparer(const ChildIsolatePreparer &value)
const fml::closure & GetIsolateCreateCallback() const
void AddKernelBuffer(const std::shared_ptr< const fml::Mapping > &buffer)
Adds a kernel buffer mapping to the kernels loaded for this isolate group.
void SetNullSafetyEnabled(bool enabled)
void SetIsDontNeedSafe(bool value)
Represents an instance of a live isolate. An isolate is a separate Dart execution context....
bool PrepareForRunningFromKernel(const std::shared_ptr< const fml::Mapping > &kernel, bool child_isolate, bool last_piece)
Prepare the isolate for running for a a list of kernel files.
std::string GetServiceId()
Returns the ID for an isolate which is used to query the service protocol.
void LoadLoadingUnitError(intptr_t loading_unit_id, const std::string &error_message, bool transient)
std::weak_ptr< DartIsolate > GetWeakIsolatePtr()
A weak pointer to the Dart isolate instance. This instance may only be used on the task runner that c...
Dart_Isolate CreatePlatformIsolate(Dart_Handle entry_point, char **error) override
Creates a new isolate in the same group as this isolate, which runs on the platform thread....
static std::weak_ptr< DartIsolate > CreateRunningRootIsolate(const Settings &settings, const fml::RefPtr< const DartSnapshot > &isolate_snapshot, std::unique_ptr< PlatformConfiguration > platform_configuration, Flags flags, const fml::closure &root_isolate_create_callback, const fml::closure &isolate_create_callback, const fml::closure &isolate_shutdown_callback, std::optional< std::string > dart_entrypoint, std::optional< std::string > dart_entrypoint_library, const std::vector< std::string > &dart_entrypoint_args, std::unique_ptr< IsolateConfiguration > isolate_configuration, const UIDartState::Context &context, const DartIsolate *spawning_isolate=nullptr)
Creates an instance of a root isolate and returns a weak pointer to the same. The isolate instance ma...
bool PrepareForRunningFromKernels(std::vector< std::shared_ptr< const fml::Mapping > > kernels)
Prepare the isolate for running for a a list of kernel files.
static Dart_Handle LoadLibraryFromKernel(const std::shared_ptr< const fml::Mapping > &mapping)
bool RunFromLibrary(std::optional< std::string > library_name, std::optional< std::string > entrypoint, const std::vector< std::string > &args)
Transition the root isolate to the Phase::Running phase and invoke the main entrypoint (the "main" me...
DartIsolateGroupData & GetIsolateGroupData()
void AddIsolateShutdownCallback(const fml::closure &closure)
Registers a callback that will be invoked in isolate scope just before the isolate transitions to the...
fml::RefPtr< fml::TaskRunner > GetMessageHandlingTaskRunner() const
The task runner on which the Dart code for the root isolate is running. For the root isolate,...
bool Shutdown()
Transition the isolate to the Phase::Shutdown phase. The only thing left to do is to collect the isol...
Phase GetPhase() const
The current phase of the isolate. The engine represents all dart isolates as being in one of the know...
bool PrepareForRunningFromPrecompiledCode()
Prepare the isolate for running for a precompiled code bundle. The Dart VM must be configured for run...
bool LoadLoadingUnit(intptr_t loading_unit_id, std::unique_ptr< const fml::Mapping > snapshot_data, std::unique_ptr< const fml::Mapping > snapshot_instructions)
Phase
The engine represents all dart isolates as being in one of the known phases. By invoking various meth...
static void Install(bool is_ui_isolate, const std::string &script_uri)
static bool Startup(const std::string &server_ip, intptr_t server_port, Dart_LibraryTagHandler embedder_tag_handler, bool disable_origin_check, bool disable_service_auth_codes, bool enable_service_port_fallback, char **error)
Start the service isolate. This call may only be made in the Dart VM initiated isolate creation callb...
static fml::RefPtr< DartSnapshot > IsolateSnapshotFromMappings(const std::shared_ptr< const fml::Mapping > &snapshot_data, const std::shared_ptr< const fml::Mapping > &snapshot_instructions)
Create an isolate snapshot from existing fml::Mappings.
static void InitForIsolate(const Settings &settings)
static std::shared_ptr< ServiceProtocol > GetServiceProtocol()
static std::shared_ptr< const DartVMData > GetVMData()
static bool IsRunningPrecompiledCode()
Checks if VM instances in the process can run precompiled code. This call can be made at any time and...
fml::RefPtr< fml::TaskRunner > GetPlatformTaskRunner() const
PlatformConfiguration * platform_configuration() const
UnhandledExceptionCallback unhandled_exception_callback() const
bool IsRootIsolate() const
const TaskRunners & GetTaskRunners() const
std::shared_ptr< IsolateNameServer > GetIsolateNameServer() const
const std::string & GetAdvisoryScriptURI() const
static UIDartState * Current()
static MessageLoopTaskQueues * GetInstance()
Wraps a closure that is invoked in the destructor unless released by the caller.
void add_provider(const std::string &library_name, std::unique_ptr< DartClassProvider > provider)
std::function< void(std::function< void(void)>)> TaskDispatcher
void Initialize(TaskDispatcher dispatcher)
void SetIsolate(Dart_Isolate isolate)
DartMessageHandler & message_handler()
static DartState * Current()
DartClassLibrary & class_library()
static Dart_Handle HandleLibraryTag(Dart_LibraryTag tag, Dart_Handle library, Dart_Handle url)
DART_EXPORT Dart_Isolate Dart_CreateIsolateGroup(const char *script_uri, const char *name, const uint8_t *isolate_snapshot_data, const uint8_t *isolate_snapshot_instructions, Dart_IsolateFlags *flags, void *isolate_group_data, void *isolate_data, char **error)
DART_EXPORT Dart_Handle Dart_HandleFromPersistent(Dart_PersistentHandle object)
DART_EXPORT void Dart_IsolateFlagsInitialize(Dart_IsolateFlags *flags)
DART_EXPORT Dart_Handle Dart_GetNonNullableType(Dart_Handle library, Dart_Handle class_name, intptr_t number_of_type_arguments, Dart_Handle *type_arguments)
DART_EXPORT DART_WARN_UNUSED_RESULT char * Dart_IsolateMakeRunnable(Dart_Isolate isolate)
void(* Dart_IsolateCleanupCallback)(void *isolate_group_data, void *isolate_data)
DART_EXPORT Dart_Handle Dart_SetDeferredLoadHandler(Dart_DeferredLoadHandler handler)
DART_EXPORT void Dart_ShutdownIsolate(void)
struct _Dart_Handle * Dart_Handle
DART_EXPORT Dart_PersistentHandle Dart_NewPersistentHandle(Dart_Handle object)
DART_EXPORT Dart_Isolate Dart_CreateIsolateInGroup(Dart_Isolate group_member, const char *name, Dart_IsolateShutdownCallback shutdown_callback, Dart_IsolateCleanupCallback cleanup_callback, void *child_isolate_data, char **error)
struct _Dart_Isolate * Dart_Isolate
DART_EXPORT bool Dart_IsFatalError(Dart_Handle handle)
DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle Dart_LoadLibraryFromKernel(const uint8_t *kernel_buffer, intptr_t kernel_buffer_size)
DART_EXPORT Dart_Handle Dart_LookupLibrary(Dart_Handle url)
DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle Dart_FinalizeLoading(bool complete_futures)
DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle Dart_SetField(Dart_Handle container, Dart_Handle name, Dart_Handle value)
DART_EXPORT Dart_Isolate Dart_CurrentIsolate(void)
DART_EXPORT bool Dart_IsKernel(const uint8_t *buffer, intptr_t buffer_size)
Dart_Handle Dart_PersistentHandle
DART_EXPORT Dart_Handle Dart_False(void)
DART_EXPORT Dart_Handle Dart_NewApiError(const char *error)
DART_EXPORT Dart_Handle Dart_Null(void)
void(* Dart_IsolateShutdownCallback)(void *isolate_group_data, void *isolate_data)
DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle Dart_DeferredLoadComplete(intptr_t loading_unit_id, const uint8_t *snapshot_data, const uint8_t *snapshot_instructions)
DART_EXPORT const char * Dart_IsolateServiceId(Dart_Isolate isolate)
DART_EXPORT bool Dart_IsNull(Dart_Handle object)
DART_EXPORT void * Dart_IsolateData(Dart_Isolate isolate)
DART_EXPORT Dart_Handle Dart_NewStringFromCString(const char *str)
DART_EXPORT void * Dart_IsolateGroupData(Dart_Isolate isolate)
DART_EXPORT Dart_Handle Dart_GetStickyError(void)
DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle Dart_GetField(Dart_Handle container, Dart_Handle name)
DART_EXPORT void Dart_EnterIsolate(Dart_Isolate isolate)
#define DART_VM_SERVICE_ISOLATE_NAME
DART_EXPORT bool Dart_IsError(Dart_Handle handle)
DART_EXPORT void Dart_ExitIsolate(void)
DART_EXPORT bool Dart_IsServiceIsolate(Dart_Isolate isolate)
DART_EXPORT void * Dart_CurrentIsolateGroupData(void)
DART_EXPORT void Dart_DeletePersistentHandle(Dart_PersistentHandle object)
DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle Dart_DeferredLoadCompleteError(intptr_t loading_unit_id, const char *error_message, bool transient)
DART_EXPORT const char * Dart_GetError(Dart_Handle handle)
DART_EXPORT Dart_Handle Dart_SetLibraryTagHandler(Dart_LibraryTagHandler handler)
DART_EXPORT Dart_Handle Dart_RootLibrary(void)
DART_EXPORT Dart_Handle Dart_SetRootLibrary(Dart_Handle library)
FlutterSemanticsFlag flags
G_BEGIN_DECLS G_MODULE_EXPORT FlValue * args
FlKeyEvent uint64_t FlKeyResponderAsyncCallback callback
const uint8_t uint32_t uint32_t GError ** error
#define FML_DLOG(severity)
#define FML_LOG(severity)
#define FML_CHECK(condition)
#define FML_DCHECK(condition)
#define FML_DISALLOW_COPY_AND_ASSIGN(TypeName)
std::function< void(intptr_t, fml::closure)> TaskObserverAdd
constexpr char kFileUriPrefix[]
bool InvokeDartPluginRegistrantIfAvailable(Dart_Handle library_handle)
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service The hostname IP address on which the Dart VM Service should be served If not defaults to or::depending on whether ipv6 is specified vm service A custom Dart VM Service port The default is to pick a randomly available open port disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode disable vm service Disable mDNS Dart VM Service publication Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set endless trace buffer
bool FindAndInvokeDartPluginRegistrant()
static bool InvokeMainEntrypoint(Dart_Handle user_entrypoint_function, Dart_Handle args)
char * strdup(const char *str1)
std::function< void()> closure
Dart_Handle ToDart(const T &object)
Dart_Handle DartInvokeVoid(Dart_Handle closure)
bool CheckAndHandleError(Dart_Handle handle)
Dart_Handle DartInvokeField(Dart_Handle target, const char *name, std::initializer_list< Dart_Handle > args)
The subset of state which is owned by the shell or engine and passed through the RuntimeController in...
std::string advisory_script_uri
std::string advisory_script_entrypoint
#define TRACE_EVENT0(category_group, name)