| // 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. |
| |
| #ifndef FLUTTER_COMMON_SETTINGS_H_ |
| #define FLUTTER_COMMON_SETTINGS_H_ |
| |
| #include <fcntl.h> |
| |
| #include <chrono> |
| #include <cstdint> |
| #include <memory> |
| #include <optional> |
| #include <string> |
| #include <vector> |
| |
| #include "flutter/fml/closure.h" |
| #include "flutter/fml/mapping.h" |
| #include "flutter/fml/time/time_point.h" |
| #include "flutter/fml/unique_fd.h" |
| |
| namespace flutter { |
| |
| class FrameTiming { |
| public: |
| enum Phase { |
| kVsyncStart, |
| kBuildStart, |
| kBuildFinish, |
| kRasterStart, |
| kRasterFinish, |
| kRasterFinishWallTime, |
| kCount |
| }; |
| |
| static constexpr Phase kPhases[kCount] = { |
| kVsyncStart, kBuildStart, kBuildFinish, |
| kRasterStart, kRasterFinish, kRasterFinishWallTime}; |
| |
| static constexpr int kStatisticsCount = kCount + 5; |
| |
| fml::TimePoint Get(Phase phase) const { return data_[phase]; } |
| fml::TimePoint Set(Phase phase, fml::TimePoint value) { |
| return data_[phase] = value; |
| } |
| |
| uint64_t GetFrameNumber() const { return frame_number_; } |
| void SetFrameNumber(uint64_t frame_number) { frame_number_ = frame_number; } |
| uint64_t GetLayerCacheCount() const { return layer_cache_count_; } |
| uint64_t GetLayerCacheBytes() const { return layer_cache_bytes_; } |
| uint64_t GetPictureCacheCount() const { return picture_cache_count_; } |
| uint64_t GetPictureCacheBytes() const { return picture_cache_bytes_; } |
| void SetRasterCacheStatistics(size_t layer_cache_count, |
| size_t layer_cache_bytes, |
| size_t picture_cache_count, |
| size_t picture_cache_bytes) { |
| layer_cache_count_ = layer_cache_count; |
| layer_cache_bytes_ = layer_cache_bytes; |
| picture_cache_count_ = picture_cache_count; |
| picture_cache_bytes_ = picture_cache_bytes; |
| } |
| |
| private: |
| fml::TimePoint data_[kCount]; |
| uint64_t frame_number_; |
| size_t layer_cache_count_; |
| size_t layer_cache_bytes_; |
| size_t picture_cache_count_; |
| size_t picture_cache_bytes_; |
| }; |
| |
| using TaskObserverAdd = |
| std::function<void(intptr_t /* key */, fml::closure /* callback */)>; |
| using TaskObserverRemove = std::function<void(intptr_t /* key */)>; |
| using UnhandledExceptionCallback = |
| std::function<bool(const std::string& /* error */, |
| const std::string& /* stack trace */)>; |
| using LogMessageCallback = |
| std::function<void(const std::string& /* tag */, |
| const std::string& /* message */)>; |
| |
| // TODO(26783): Deprecate all the "path" struct members in favor of the |
| // callback that generates the mapping from these paths. |
| using MappingCallback = std::function<std::unique_ptr<fml::Mapping>(void)>; |
| using Mappings = std::vector<std::unique_ptr<const fml::Mapping>>; |
| using MappingsCallback = std::function<Mappings(void)>; |
| |
| using FrameRasterizedCallback = std::function<void(const FrameTiming&)>; |
| |
| class DartIsolate; |
| |
| struct Settings { |
| Settings(); |
| |
| Settings(const Settings& other); |
| |
| ~Settings(); |
| |
| // VM settings |
| std::string vm_snapshot_data_path; // deprecated |
| MappingCallback vm_snapshot_data; |
| std::string vm_snapshot_instr_path; // deprecated |
| MappingCallback vm_snapshot_instr; |
| |
| std::string isolate_snapshot_data_path; // deprecated |
| MappingCallback isolate_snapshot_data; |
| std::string isolate_snapshot_instr_path; // deprecated |
| MappingCallback isolate_snapshot_instr; |
| |
| std::string route; |
| |
| // Returns the Mapping to a kernel buffer which contains sources for dart:* |
| // libraries. |
| MappingCallback dart_library_sources_kernel; |
| |
| // Path to a library containing the application's compiled Dart code. |
| // This is a vector so that the embedder can provide fallback paths in |
| // case the primary path to the library can not be loaded. |
| std::vector<std::string> application_library_path; |
| |
| // Path to a library containing compiled Dart code usable for launching |
| // the VM service isolate. |
| std::vector<std::string> vmservice_snapshot_library_path; |
| |
| std::string application_kernel_asset; // deprecated |
| std::string application_kernel_list_asset; // deprecated |
| MappingsCallback application_kernels; |
| |
| std::string temp_directory_path; |
| std::vector<std::string> dart_flags; |
| // Isolate settings |
| bool enable_checked_mode = false; |
| bool start_paused = false; |
| bool trace_skia = false; |
| std::vector<std::string> trace_allowlist; |
| std::optional<std::vector<std::string>> trace_skia_allowlist; |
| bool trace_startup = false; |
| bool trace_systrace = false; |
| bool enable_timeline_event_handler = true; |
| bool dump_skp_on_shader_compilation = false; |
| bool cache_sksl = false; |
| bool purge_persistent_cache = false; |
| bool endless_trace_buffer = false; |
| bool enable_dart_profiling = false; |
| bool disable_dart_asserts = false; |
| bool enable_serial_gc = false; |
| |
| // Whether embedder only allows secure connections. |
| bool may_insecurely_connect_to_all_domains = true; |
| // JSON-formatted domain network policy. |
| std::string domain_network_policy; |
| |
| // Used as the script URI in debug messages. Does not affect how the Dart code |
| // is executed. |
| std::string advisory_script_uri = "main.dart"; |
| // Used as the script entrypoint in debug messages. Does not affect how the |
| // Dart code is executed. |
| std::string advisory_script_entrypoint = "main"; |
| |
| // The executable path associated with this process. This is returned by |
| // Platform.executable from dart:io. If unknown, defaults to "Flutter". |
| std::string executable_name = "Flutter"; |
| |
| // Observatory settings |
| |
| // Whether the Dart VM service should be enabled. |
| bool enable_observatory = false; |
| |
| // Whether to publish the observatory URL over mDNS. |
| // On iOS 14 this prompts a local network permission dialog, |
| // which cannot be accepted or dismissed in a CI environment. |
| bool enable_observatory_publication = true; |
| |
| // The IP address to which the Dart VM service is bound. |
| std::string observatory_host; |
| |
| // The port to which the Dart VM service is bound. When set to `0`, a free |
| // port will be automatically selected by the OS. A message is logged on the |
| // target indicating the URL at which the VM service can be accessed. |
| uint32_t observatory_port = 0; |
| |
| // Determines whether an authentication code is required to communicate with |
| // the VM service. |
| bool disable_service_auth_codes = true; |
| |
| // Determine whether the vmservice should fallback to automatic port selection |
| // after failing to bind to a specified port. |
| bool enable_service_port_fallback = false; |
| |
| // Font settings |
| bool use_test_fonts = false; |
| |
| bool use_asset_fonts = true; |
| |
| // Indicates whether the embedding started a prefetch of the default font |
| // manager before creating the engine. |
| bool prefetched_default_font_manager = false; |
| |
| // Selects the SkParagraph implementation of the text layout engine. |
| bool enable_skparagraph = false; |
| |
| // Enable the Impeller renderer on supported platforms. Ignored if Impeller is |
| // not supported on the platform. |
| bool enable_impeller = false; |
| |
| // Data set by platform-specific embedders for use in font initialization. |
| uint32_t font_initialization_data = 0; |
| |
| // All shells in the process share the same VM. The last shell to shutdown |
| // should typically shut down the VM as well. However, applications depend on |
| // the behavior of "warming-up" the VM by creating a shell that does not do |
| // anything. This used to work earlier when the VM could not be shut down (and |
| // hence never was). Shutting down the VM now breaks such assumptions in |
| // existing embedders. To keep this behavior consistent and allow existing |
| // embedders the chance to migrate, this flag defaults to true. Any shell |
| // launched with this flag set to true will leak the VM in the process. There |
| // is no way to shut down the VM once such a shell has been started. All |
| // shells in the platform (via their embedding APIs) should cooperate to make |
| // sure this flag is never set if they want the VM to shutdown and free all |
| // associated resources. |
| // It can be customized by application, more detail: |
| // https://github.com/flutter/flutter/issues/95903 |
| // TODO(eggfly): Should it be set to false by default? |
| // https://github.com/flutter/flutter/issues/96843 |
| bool leak_vm = true; |
| |
| // Engine settings |
| TaskObserverAdd task_observer_add; |
| TaskObserverRemove task_observer_remove; |
| // The main isolate is current when this callback is made. This is a good spot |
| // to perform native Dart bindings for libraries not built in. |
| std::function<void(const DartIsolate&)> root_isolate_create_callback; |
| // TODO(68738): Update isolate callbacks in settings to accept an additional |
| // DartIsolate parameter. |
| fml::closure isolate_create_callback; |
| // The isolate is not current and may have already been destroyed when this |
| // call is made. |
| fml::closure root_isolate_shutdown_callback; |
| fml::closure isolate_shutdown_callback; |
| // A callback made in the isolate scope of the service isolate when it is |
| // launched. Care must be taken to ensure that callers are assigning callbacks |
| // to the settings object used to launch the VM. If an existing VM is used to |
| // launch an isolate using these settings, the callback will be ignored as the |
| // service isolate has already been launched. Also, this callback will only be |
| // made in the modes in which the service isolate is eligible for launch |
| // (debug and profile). |
| fml::closure service_isolate_create_callback; |
| // The callback made on the UI thread in an isolate scope when the engine |
| // detects that the framework is idle. The VM also uses this time to perform |
| // tasks suitable when idling. Due to this, embedders are still advised to be |
| // as fast as possible in returning from this callback. Long running |
| // operations in this callback do have the capability of introducing jank. |
| std::function<void(int64_t)> idle_notification_callback; |
| // A callback given to the embedder to react to unhandled exceptions in the |
| // running Flutter application. This callback is made on an internal engine |
| // managed thread and embedders must re-thread as necessary. Performing |
| // blocking calls in this callback will cause applications to jank. |
| UnhandledExceptionCallback unhandled_exception_callback; |
| // A callback given to the embedder to log print messages from the running |
| // Flutter application. This callback is made on an internal engine managed |
| // thread and embedders must re-thread if necessary. Performing blocking |
| // calls in this callback will cause applications to jank. |
| LogMessageCallback log_message_callback; |
| bool enable_software_rendering = false; |
| bool skia_deterministic_rendering_on_cpu = false; |
| bool verbose_logging = false; |
| std::string log_tag = "flutter"; |
| |
| // The icu_initialization_required setting does not have a corresponding |
| // switch because it is intended to be decided during build time, not runtime. |
| // Some companies apply source modification here because their build system |
| // brings its own ICU data files. |
| bool icu_initialization_required = true; |
| std::string icu_data_path; |
| MappingCallback icu_mapper; |
| |
| // Assets settings |
| fml::UniqueFD::element_type assets_dir = |
| fml::UniqueFD::traits_type::InvalidValue(); |
| std::string assets_path; |
| |
| // Callback to handle the timings of a rasterized frame. This is called as |
| // soon as a frame is rasterized. |
| FrameRasterizedCallback frame_rasterized_callback; |
| |
| // This data will be available to the isolate immediately on launch via the |
| // PlatformDispatcher.getPersistentIsolateData callback. This is meant for |
| // information that the isolate cannot request asynchronously (platform |
| // messages can be used for that purpose). This data is held for the lifetime |
| // of the shell and is available on isolate restarts in the shell instance. |
| // Due to this, the buffer must be as small as possible. |
| std::shared_ptr<const fml::Mapping> persistent_isolate_data; |
| |
| /// Max size of old gen heap size in MB, or 0 for unlimited, -1 for default |
| /// value. |
| /// |
| /// See also: |
| /// https://github.com/dart-lang/sdk/blob/ca64509108b3e7219c50d6c52877c85ab6a35ff2/runtime/vm/flag_list.h#L150 |
| int64_t old_gen_heap_size = -1; |
| |
| // Max bytes threshold of resource cache, or 0 for unlimited. |
| size_t resource_cache_max_bytes_threshold = 0; |
| |
| /// The minimum number of samples to require in multipsampled anti-aliasing. |
| /// |
| /// Setting this value to 0 or 1 disables MSAA. |
| /// If it is not 0 or 1, it must be one of 2, 4, 8, or 16. However, if the |
| /// GPU does not support the requested sampling value, MSAA will be disabled. |
| uint8_t msaa_samples = 0; |
| }; |
| |
| } // namespace flutter |
| |
| #endif // FLUTTER_COMMON_SETTINGS_H_ |