Flutter Engine
flutter Namespace Reference

Namespaces

 internal
 
 runtime
 
 testing
 

Classes

class  AccessibilityBridge
 
class  AccessibilityBridgeIos
 Interface that represents an accessibility bridge for iOS. More...
 
class  AccessibilityBridgeMacDelegate
 
class  AndroidContext
 Holds state that is shared across Android surfaces. More...
 
class  AndroidContextGL
 
class  AndroidDisplay
 A |Display| that listens to refresh rate changes. More...
 
class  AndroidEGLSurface
 
class  AndroidEnvironmentGL
 
class  AndroidExternalTextureGL
 
class  AndroidExternalViewEmbedder
 
class  AndroidImageGenerator
 
class  AndroidNativeWindow
 
class  AndroidShellHolder
 This is the Android owner of the core engine Shell. More...
 
class  AndroidSnapshotSurfaceProducer
 
class  AndroidSurface
 
class  AndroidSurfaceFactory
 
class  AndroidSurfaceFactoryImpl
 
class  AndroidSurfaceGL
 
class  AndroidSurfaceMock
 
class  AndroidSurfaceSoftware
 
class  AngleSurfaceManager
 
class  Animator
 
class  APKAssetMapping
 
class  APKAssetProvider
 
class  Application
 
class  ApplicationStore
 
class  AppSnapshotIsolateConfiguration
 
class  AssetManager
 
class  AssetManagerFontProvider
 
class  AssetManagerFontStyleSet
 
class  AssetResolver
 
class  BackdropFilterLayer
 
class  BasicMessageChannel
 
class  BinaryMessenger
 
class  BinaryMessengerImpl
 
class  BoundsAccumulator
 
class  BuiltinSkiaCodecImageGenerator
 
class  BuiltinSkiaImageGenerator
 
class  ByteBufferStreamReader
 
class  ByteBufferStreamWriter
 
class  ByteStreamReader
 
class  ByteStreamWriter
 
class  Canvas
 
class  CanvasGradient
 
class  CanvasImage
 
class  CanvasPath
 
class  CanvasPathMeasure
 
class  CanvasSpy
 
class  ClipBoundsDispatchHelper
 
class  ClipPathLayer
 
class  ClipRectLayer
 
class  ClipRRectLayer
 
class  Codec
 
class  ColorFilter
 
class  ColorFilterLayer
 
class  Command
 
class  CompositorContext
 
class  ConnectionCollection
 Maintains a current integer assigned to a name (connections). More...
 
class  ContainerLayer
 
class  Counter
 
class  CounterValues
 
struct  CpuUsageInfo
 CPU usage stats. num_threads is the number of threads owned by the process. It is to be noted that this is not per shell, there can be multiple shells within the process. total_cpu_usage is the percentage (between [0, 100]) cpu usage of the application. This is across all the cores, for example an application using 100% of all the core will report total_cpu_usage as 100, if it has 100% across 2 cores and 0% across the other cores, embedder must report total_cpu_usage as 50. More...
 
class  CursorHandler
 
struct  CustomAccessibilityAction
 
class  CustomEncodableValue
 
struct  Damage
 
class  DartCallbackCache
 
struct  DartCallbackRepresentation
 
class  DartIO
 
class  DartIsolate
 Represents an instance of a live isolate. An isolate is a separate Dart execution context. Different Dart isolates don't share memory and can be scheduled concurrently by the Dart VM on one of the Dart VM managed worker pool threads. More...
 
class  DartIsolateGroupData
 
class  DartProject
 
class  DartProjectTest
 
class  DartRuntimeHooks
 
class  DartServiceIsolate
 Utility methods for interacting with the DartVM managed service isolate present in debug and profile runtime modes. More...
 
class  DartSnapshot
 A read-only Dart heap snapshot, or, read-executable mapping of AOT compiled Dart code. More...
 
class  DartUI
 
class  DartVM
 Describes a running instance of the Dart VM. There may only be one running instance of the Dart VM in the process at any given time. The Dart VM may be created and destroyed on any thread. Typically, the first Flutter shell instance running in the process bootstraps the Dart VM in the process as it starts up. This cost is borne on the platform task runner of that first Flutter shell. When the last Flutter shell instance is destroyed, the VM is destroyed as well if all shell instances were launched with the Settings::leak_vm flag set to false. If there is any shell launch in the process with leak_vm set to true, the VM is never shut down in the process. When the VM is shutdown, the cost of the shutdown is borne on the platform task runner of the last shell instance to be shut down. More...
 
class  DartVMData
 Provides thread-safe access to data that is necessary to bootstrap a new Dart VM instance. All snapshots referenced by this object are read-only. More...
 
class  DartVMRef
 
class  DefaultPointerDataDispatcher
 
class  DidDrawCanvas
 
class  DiffContext
 
class  DirectoryAssetBundle
 
class  Dispatcher
 
class  Display
 
class  DisplayHelperWinUWP
 
class  DisplayList
 
class  DisplayListAttributeFlags
 
class  DisplayListBoundsCalculator
 
class  DisplayListBuilder
 
class  DisplayListCanvasDispatcher
 
class  DisplayListCanvasRecorder
 
class  DisplayListFlags
 
class  DisplayListFlagsBase
 
class  DisplayListLayer
 
class  DisplayListOpFlags
 
class  DisplayListSpecialGeometryFlags
 
class  DisplayManager
 Manages lifecycle of the connected displays. This class is thread-safe. More...
 
struct  DLOp
 
struct  DrawArcOp
 
struct  DrawAtlasBaseOp
 
struct  DrawAtlasCulledOp
 
struct  DrawAtlasOp
 
struct  DrawColorOp
 
struct  DrawDisplayListOp
 
struct  DrawImageLatticeOp
 
struct  DrawImageRectOp
 
struct  DrawPaintOp
 
struct  DrawPathOp
 
struct  DrawSkPictureMatrixOp
 
struct  DrawSkPictureOp
 
struct  DrawTextBlobOp
 
struct  DrawVerticesOp
 
class  EmbeddedViewParams
 
class  EmbedderEngine
 
class  EmbedderExternalTextureGL
 
class  EmbedderExternalTextureMetal
 
class  EmbedderExternalTextureResolver
 
class  EmbedderExternalView
 
class  EmbedderExternalViewEmbedder
 The external view embedder used by the generic embedder API. This class acts a proxy between the rasterizer and the embedder when the rasterizer is rendering into multiple layers. It asks the embedder for the render targets for the various layers the rasterizer is rendering into, recycles the render targets as necessary and converts rasterizer specific metadata into an embedder friendly format so that it can present the layers on-screen. More...
 
class  EmbedderLayers
 
class  EmbedderPlatformMessageResponse
 The platform message response subclass for responses to messages from the embedder to the framework. Message responses are fulfilled by the framework. More...
 
class  EmbedderRenderTarget
 Describes a surface whose backing store is managed by the embedder. The type of surface depends on the client rendering API used. The embedder is notified of the collection of this render target via a callback. More...
 
class  EmbedderRenderTargetCache
 A cache used to reference render targets that are owned by the embedder but needed by th engine to render a frame. More...
 
class  EmbedderResources
 
class  EmbedderSurface
 
class  EmbedderSurfaceGL
 
class  EmbedderSurfaceMetal
 
class  EmbedderSurfaceSoftware
 
class  EmbedderTaskRunner
 
class  EmbedderThreadHost
 
class  EncodableValue
 
class  Engine
 
class  EngineLayer
 
class  EngineMethodResult
 
class  EngineModifier
 
class  EventChannel
 
class  EventLoop
 
class  EventSink
 
class  ExternalTextureGL
 
struct  ExternalTextureGLState
 
class  ExternalViewEmbedder
 
class  Fixture
 
class  FlutterCompositor
 
class  FlutterEngine
 
class  FlutterEventTracer
 
class  FlutterGLCompositor
 
class  FlutterMain
 
class  FlutterMetalCompositor
 
class  FlutterPlatformNodeDelegate
 
class  FlutterPlatformNodeDelegateMac
 
struct  FlutterPlatformViewLayer
 
class  FlutterPlatformViewLayerPool
 
class  FlutterPlatformViewsController
 
class  FlutterProjectBundle
 
class  FlutterTextPlatformNode
 The ax platform node for a text field. More...
 
class  FlutterView
 
class  FlutterViewController
 
class  FlutterWindow
 
class  FlutterWindowController
 
class  FlutterWindowsEngine
 
class  FlutterWindowsTextureRegistrar
 
class  FlutterWindowsView
 
class  FlutterWindowWin32
 
class  FlutterWindowWinUWP
 
class  FontCollection
 
class  FragmentProgram
 
class  FragmentShader
 
class  FrameDamage
 
class  FrameTiming
 
class  FrameTimingsRecorder
 
class  GamepadCursorWinUWP
 
class  GamepadWinUWP
 
class  GLContextDefaultResult
 
class  GLContextResult
 
class  GLContextSwitch
 
struct  GLFrameInfo
 
class  GLFWEventLoop
 
struct  GlProcs
 
struct  GPUMTLTextureInfo
 
class  GPUSurfaceGL
 
class  GPUSurfaceGLDelegate
 
class  GPUSurfaceMetal
 
class  GPUSurfaceMetalDelegate
 Interface implemented by all platform surfaces that can present a metal backing store to the "screen". The GPU surface abstraction (which abstracts the client rendering API) uses this delegation pattern to tell the platform surface (which abstracts how backing stores fulfilled by the selected client rendering API end up on the "screen" on a particular platform) when the rasterizer needs to allocate and present the software backing store. More...
 
class  GPUSurfaceSoftware
 
class  GPUSurfaceSoftwareDelegate
 Interface implemented by all platform surfaces that can present a software backing store to the "screen". The GPU surface abstraction (which abstracts the client rendering API) uses this delegation pattern to tell the platform surface (which abstracts how backing stores fulfilled by the selected client rendering API end up on the "screen" on a particular platform) when the rasterizer needs to allocate and present the software backing store. More...
 
class  GPUSurfaceVulkan
 
class  GPUSurfaceVulkanDelegate
 
struct  GpuUsageInfo
 Polled information related to the usage of the GPU. More...
 
class  HeadlessEventLoop
 
class  IgnoreAttributeDispatchHelper
 
class  IgnoreClipDispatchHelper
 
class  IgnoreTransformDispatchHelper
 
class  ImageDecoder
 
class  ImageDescriptor
 Creates an image descriptor for encoded or decoded image data, describing the width, height, and bytes per pixel for that image. This class will hold a reference on the underlying image data, and in the case of compressed data, an ImageGenerator for the data. The Codec initialization actually happens in initEncoded, making initstantiateCodec a lightweight operation. More...
 
class  ImageFilter
 
class  ImageFilterLayer
 
class  ImageGenerator
 The minimal interface necessary for defining a decoder that can be used for both single and multi-frame image decoding. Image generators can also optionally support decoding into a subscaled buffer. Implementers of ImageGenerator regularly keep internal state which is not thread safe, and so aliasing and parallel access should never be done with ImageGenerators. More...
 
class  ImageGeneratorRegistry
 Keeps a priority-ordered registry of image generator builders to be used when decoding images. This object must be created, accessed, and collected on the UI thread (typically the engine or its runtime controller). More...
 
struct  ImageMetaData
 
class  ImageShader
 
class  ImmContext
 
class  ImmutableBuffer
 
class  IncomingMessageDispatcher
 
class  InstallCommand
 
class  IOManager
 
class  IOSContext
 Manages the lifetime of the on-screen and off-screen rendering contexts on iOS. On-screen contexts are used by Flutter for rendering into the surface. The lifecycle of this context may be tied to the lifecycle of the surface. On the other hand, the lifecycle of the off-screen context it tied to that of the platform view. This one object used to manage both context because GPU handles may need to be shared between the two context. To achieve this, context may need references to one another at creation time. This one object manages the creation, use and collection of both contexts in a client rendering API agnostic manner. More...
 
class  IOSContextGL
 
class  IOSContextMetal
 
class  IOSContextSoftware
 
class  IOSExternalTextureGL
 
class  IOSExternalTextureMetal
 
class  IOSExternalViewEmbedder
 
class  IOSRenderTargetGL
 
class  IOSSurface
 
class  IOSSurfaceGL
 
class  IOSSurfaceMetal
 
class  IOSSurfaceSoftware
 
class  IOSSwitchableGLContext
 
class  IsolateConfiguration
 An isolate configuration is a collection of snapshots and asset managers that the engine will use to configure the isolate before invoking its root entrypoint. The set of snapshots must be sufficient for the engine to move the isolate from the |DartIsolate::Phase::LibrariesSetup| phase to the |DartIsolate::Phase::Ready| phase. Note that the isolate configuration will not be collected till the isolate tied to the configuration as well as any and all child isolates of that isolate are collected. The engine may ask the configuration to prepare multiple isolates. All subclasses of this class must be thread safe as the configuration may be created, collected and used on multiple threads. Usually these threads are engine or VM managed so care must be taken to ensure that subclasses do not reference any thread local state. More...
 
class  IsolateNameServer
 
class  IsolateNameServerNatives
 
class  JNIMock
 
class  JsonMessageCodec
 
class  JsonMethodCodec
 
class  KernelIsolateConfiguration
 
class  KernelListIsolateConfiguration
 
class  KeyboardHandlerBase
 
class  KeyboardHookHandler
 
class  KeyboardKeyChannelHandler
 
class  KeyboardKeyEmbedderHandler
 
class  KeyboardKeyHandler
 
struct  KeyData
 
class  KeyDataPacket
 
class  KeyEventHandler
 
struct  LanguageInfo
 
class  LaunchCommand
 
class  Layer
 
class  LayerTree
 
struct  LineMetrics
 
class  ListAppsCommand
 
struct  LocaleStringAttribute
 
struct  MemoryUsageInfo
 Memory usage stats. dirty_memory_usage is the memory usage (in MB) such that the app uses its physical memory for dirty memory. Dirty memory is the memory data that cannot be paged to disk. owned_shared_memory_usage is the memory usage (in MB) such that the app uses its physical memory for shared memory, including loaded frameworks and executables. On iOS, it's physical memory - dirty memory. More...
 
class  MergedContainerLayer
 
class  MessageCodec
 
class  MethodCall
 
class  MethodChannel
 
class  MethodCodec
 
class  MethodResult
 
class  MethodResultFunctions
 
class  MultiFrameCodec
 
class  Mutator
 
class  MutatorsStack
 
class  NativeStringAttribute
 The peer class for all of the StringAttribute subclasses in semantics.dart. More...
 
class  OpacityLayer
 
struct  OverlayLayer
 
class  Paint
 
class  PaintData
 
class  PaintRegion
 
class  Paragraph
 
class  ParagraphBuilder
 
class  PerformanceOverlayLayer
 
class  PersistentCache
 
class  PhysicalShapeLayer
 
struct  PhysicalWindowBounds
 
class  Picture
 
class  PictureLayer
 
class  PictureRecorder
 
class  Pipeline
 
class  PixelBufferTexture
 
class  PlatformConfiguration
 A class for holding and distributing platform-level information to and from the Dart code in Flutter's framework. More...
 
class  PlatformConfigurationClient
 A client interface that the RuntimeController uses to define handlers for PlatformConfiguration requests. More...
 
struct  PlatformData
 
class  PlatformHandler
 
class  PlatformHandlerWin32
 
class  PlatformHandlerWinUwp
 
class  PlatformMessage
 
class  PlatformMessageHandler
 
class  PlatformMessageHandlerAndroid
 
class  PlatformMessageHandlerIos
 
class  PlatformMessageResponse
 
class  PlatformMessageResponseAndroid
 
class  PlatformMessageResponseDart
 
class  PlatformMessageResponseDarwin
 
class  PlatformView
 Platform views are created by the shell on the platform task runner. Unless explicitly specified, all platform view methods are called on the platform task runner as well. Platform views are usually sub-classed on a per platform basis and the bulk of the window system integration happens using that subclass. Since most platform window toolkits are usually only safe to access on a single "main" thread, any interaction that requires access to the underlying platform's window toolkit is routed through the platform view associated with that shell. This involves operations like settings up and tearing down the render surface, platform messages, interacting with accessibility features on the platform, input events, etc. More...
 
class  PlatformViewAndroid
 
class  PlatformViewAndroidDelegate
 
class  PlatformViewAndroidJNI
 
class  PlatformViewAndroidJNIImpl
 Concrete implementation of PlatformViewAndroidJNI that is compiled with the Android toolchain. More...
 
class  PlatformViewEmbedder
 
class  PlatformViewIOS
 
class  PlatformViewLayer
 
class  Plugin
 
class  PluginRegistrar
 
class  PluginRegistrarGlfw
 
class  PluginRegistrarManager
 
class  PluginRegistrarWindows
 
class  PluginRegistry
 
class  Point
 
struct  PointerData
 
class  PointerDataDispatcher
 
class  PointerDataPacket
 
class  PointerDataPacketConverter
 
struct  PointerState
 
class  PointExtensionSerializer
 
struct  PrerollContext
 
class  ProfilerMetricsIOS
 Utility class that gathers profiling metrics used by flutter::SamplingProfiler. More...
 
struct  ProfileSample
 Container for the metrics we collect during each run of Sampler. This currently holds CpuUsageInfo and MemoryUsageInfo but the intent is to expand it to other metrics. More...
 
class  RasterCache
 
class  RasterCacheKey
 
struct  RasterCacheMetrics
 
class  RasterCacheResult
 
class  Rasterizer
 
class  Rect
 
class  RefCountedDartWrappable
 
struct  RestoreOp
 
struct  RotateOp
 
class  RRect
 
class  RTree
 
class  RTreeFactory
 
class  RunConfiguration
 Specifies all the configuration required by the runtime library to launch the root isolate. This object may be created on any thread but must be given to the |Run| call of the |Engine| on the UI thread. The configuration object is used to specify how the root isolate finds its snapshots, assets, root library and the "main" entrypoint. More...
 
class  RuntimeController
 
class  RuntimeDelegate
 
class  SamplingProfiler
 a Sampling Profiler that runs peridically and calls the Sampler which servers as a value function to gather various profiling metrics as represented by ProfileSample. These profiling metrics are then posted to the observatory timeline. More...
 
struct  SaveLayerBoundsOp
 
struct  SaveLayerOp
 
struct  SaveOp
 
struct  ScaleOp
 
class  Scene
 
class  SceneBuilder
 
class  ScriptCompletionTaskObserver
 
struct  SemanticsNode
 
class  SemanticsUpdate
 
class  SemanticsUpdateBuilder
 
class  SequentialIdGenerator
 
class  ServiceProtocol
 
struct  SetBlendModeOp
 
struct  SetColorOp
 
struct  SetStrokeMiterOp
 
struct  SetStrokeWidthOp
 
struct  SetStyleOp
 
struct  Settings
 
class  Shader
 
class  ShaderMaskLayer
 
class  Shell
 
struct  ShellArgs
 
class  ShellIOManager
 
class  ShellTestExternalViewEmbedder
 The external view embedder used by |ShellTestPlatformViewGL|. More...
 
class  SingleFrameCodec
 
class  Size
 
struct  SkewOp
 
class  SkiaConcurrentExecutor
 An interface used by Skia to schedule work on engine managed threads (usually workers in a concurrent message loop). More...
 
class  SkiaGPUObject
 
class  SkiaUnrefQueue
 
class  SkMatrixDispatchHelper
 
class  SkMatrixSource
 
class  SkPaintDispatchHelper
 
class  SmoothPointerDataDispatcher
 
class  SnapshotDelegate
 
class  SnapshotSurfaceProducer
 
class  SomeData
 
class  SomeDataExtensionSerializer
 
struct  SpellOutStringAttribute
 
class  StandardCodecSerializer
 
class  StandardMessageCodec
 
class  StandardMethodCodec
 
class  Stopwatch
 
class  StreamHandler
 
struct  StreamHandlerError
 
class  StreamHandlerFunctions
 
struct  StringAttribute
 
class  Surface
 Abstract Base Class that represents where we will be rendering content. More...
 
class  SurfaceFrame
 
class  SurfacePool
 
class  SwitchableGLContext
 
class  TaskRunner
 
class  TaskRunners
 
class  TaskRunnerWin32
 
class  TaskRunnerWin32Window
 
class  TaskRunnerWinUwp
 
class  TestAccessibilityBridgeDelegate
 
class  TestBinaryMessenger
 
class  TestCustomValue
 
class  TesterExternalViewEmbedder
 
class  TesterPlatformView
 
class  TestMetalContext
 
class  TestMetalSurface
 Creates a MTLTexture backed SkSurface and context that can be used to render to in unit-tests. More...
 
class  TestMetalSurfaceImpl
 
class  TestVulkanContext
 Utility class to create a Vulkan device context, a corresponding Skia context, and device resources. More...
 
struct  TextBox
 
struct  TextEditingDelta
 A change in the state of an input field. More...
 
class  TextInputManagerWin32
 
class  TextInputModel
 
class  TextInputPlugin
 
class  TextInputPluginDelegate
 
class  TextRange
 
class  Texture
 
class  TextureLayer
 
class  TextureRegistrar
 
class  TextureRegistrarImpl
 
class  TextureRegistry
 
struct  ThreadHost
 The collection of all the threads used by the engine. More...
 
struct  Transform2DAffineOp
 
struct  TransformFullPerspectiveOp
 
class  TransformLayer
 
struct  TranslateOp
 
class  UIDartState
 
class  UninstallCommand
 
class  Vertices
 
struct  ViewportMetrics
 
class  VolatilePathTracker
 
class  VsyncWaiter
 
class  VsyncWaiterAndroid
 
class  VsyncWaiterEmbedder
 
class  VsyncWaiterFallback
 A |VsyncWaiter| that will fire at 60 fps irrespective of the vsync. More...
 
class  VsyncWaiterIOS
 
class  Window
 
class  WindowBindingHandler
 
class  WindowBindingHandlerDelegate
 
struct  WindowBoundsWinUWP
 
struct  WindowFrame
 
class  WindowProcDelegateManagerWin32
 
struct  WindowProperties
 
class  WindowWin32
 

Typedefs

using TaskObserverAdd = std::function< void(intptr_t, fml::closure)>
 
using TaskObserverRemove = std::function< void(intptr_t)>
 
using UnhandledExceptionCallback = std::function< bool(const std::string &, const std::string &)>
 
using LogMessageCallback = std::function< void(const std::string &, const std::string &)>
 
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 &)>
 
using PaintRegionMap = std::map< uint64_t, PaintRegion >
 
using PictureRasterCacheKey = RasterCacheKey< uint32_t >
 
using DisplayListRasterCacheKey = RasterCacheKey< uint32_t >
 
using LayerRasterCacheKey = RasterCacheKey< uint64_t >
 
typedef CanvasGradient Gradient
 
typedef CanvasImage Image
 
using ImageGeneratorFactory = std::function< std::shared_ptr< ImageGenerator >(sk_sp< SkData > buffer)>
 ImageGeneratorFactory is the top level primitive for specifying an image decoder in Flutter. When called, it should return an ImageGenerator that typically compatible with the given input data. More...
 
typedef CanvasPath Path
 
typedef CanvasPathMeasure PathMeasure
 
using CustomAccessibilityActionUpdates = std::unordered_map< int32_t, CustomAccessibilityAction >
 
using SemanticsNodeUpdates = std::unordered_map< int32_t, SemanticsNode >
 
using StringAttributePtr = std::shared_ptr< flutter::StringAttribute >
 
using StringAttributes = std::vector< StringAttributePtr >
 
using ChildIsolatePreparer = std::function< bool(DartIsolate *)>
 
typedef uint64_t DisplayId
 
using PointerDataDispatcherMaker = std::function< std::unique_ptr< PointerDataDispatcher >(PointerDataDispatcher::Delegate &)>
 Signature for constructing PointerDataDispatcher. More...
 
typedef void * GPUMTLDeviceHandle
 
typedef void * GPUMTLCommandQueueHandle
 
typedef void * GPUCAMetalLayerHandle
 
typedef const void * GPUMTLTextureHandle
 
template<class T >
using EGLResult = std::pair< bool, T >
 
using JavaLocalRef = std::nullptr_t
 
template<typename T >
using MessageReply = std::function< void(const T &reply)>
 
template<typename T >
using MessageHandler = std::function< void(const T &message, const MessageReply< T > &reply)>
 
typedef std::function< void(const uint8_t *reply, size_t reply_size)> BinaryReply
 
typedef std::function< void(const uint8_t *message, size_t message_size, BinaryReply reply)> BinaryMessageHandler
 
using EncodableList = std::vector< EncodableValue >
 
using EncodableMap = std::map< EncodableValue, EncodableValue >
 
template<typename T >
using StreamHandlerListen = std::function< std::unique_ptr< StreamHandlerError< T > >(const T *arguments, std::unique_ptr< EventSink< T > > &&events)>
 
template<typename T >
using StreamHandlerCancel = std::function< std::unique_ptr< StreamHandlerError< T > >(const T *arguments)>
 
template<typename T >
using MethodCallHandler = std::function< void(const MethodCall< T > &call, std::unique_ptr< MethodResult< T > > result)>
 
template<typename T >
using ResultHandlerSuccess = std::function< void(const T *result)>
 
template<typename T >
using ResultHandlerError = std::function< void(const std::string &error_code, const std::string &error_message, const T *error_details)>
 
template<typename T >
using ResultHandlerNotImplemented = std::function< void()>
 
typedef std::variant< PixelBufferTextureTextureVariant
 
typedef ui::AXNode::AXID AccessibilityNodeId
 
using WindowProcDelegate = std::function< std::optional< LRESULT >(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)>
 
typedef struct ExternalTextureGLState ExternalTextureGLState
 
typedef void(* glGenTexturesProc) (GLsizei n, GLuint *textures)
 
typedef void(* glDeleteTexturesProc) (GLsizei n, const GLuint *textures)
 
typedef void(* glBindTextureProc) (GLenum target, GLuint texture)
 
typedef void(* glTexParameteriProc) (GLenum target, GLenum pname, GLint param)
 
typedef void(* glTexImage2DProc) (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *data)
 
using UniqueAotDataPtr = std::unique_ptr< _FlutterEngineAOTData, FlutterEngineCollectAOTDataFnPtr >
 
using GamepadSingleAxisCallback = std::function< void(double)>
 
using GamepadDualAxisCallback = std::function< void(double, double)>
 
using GamepadButtonCallback = std::function< void(winrt::Windows::Gaming::Input::GamepadButtons)>
 
using GamepadAddedRemovedCallback = std::function< void()>
 
typedef uint64_t(* CurrentTimeProc) ()
 
using PlatformWindow = HWND
 
using WindowsRenderTarget = std::variant< HWND >
 
using Sampler = std::function< ProfileSample(void)>
 Sampler is run during SamplingProfiler::SampleRepeatedly. Each platform should implement its version of a Sampler if they decide to participate in gathering profiling metrics. More...
 

Enumerations

enum  RasterStatus {
  RasterStatus::kSuccess,
  RasterStatus::kResubmit,
  RasterStatus::kSkipAndRetry,
  RasterStatus::kEnqueuePipeline,
  RasterStatus::kFailed,
  RasterStatus::kDiscarded,
  RasterStatus::kYielded
}
 
enum  DisplayListCompare {
  DisplayListCompare::kUseBulkCompare,
  DisplayListCompare::kNotEqual,
  DisplayListCompare::kEqual
}
 
enum  DisplayListOpType { DisplayListOpType::FOR_EACH_DISPLAY_LIST_OP =(DL_OP_TO_ENUM_VALUE) }
 
enum  MutatorType {
  clip_rect,
  clip_rrect,
  clip_path,
  transform,
  opacity
}
 
enum  PostPrerollResult {
  PostPrerollResult::kSuccess,
  PostPrerollResult::kResubmitFrame,
  PostPrerollResult::kSkipAndRetryFrame
}
 
enum  Clip {
  none,
  hardEdge,
  antiAlias,
  antiAliasWithSaveLayer
}
 
enum  MaskFilterType {
  Null,
  Blur
}
 
enum  SemanticsAction : int32_t {
  SemanticsAction::kTap = 1 << 0,
  SemanticsAction::kLongPress = 1 << 1,
  SemanticsAction::kScrollLeft = 1 << 2,
  SemanticsAction::kScrollRight = 1 << 3,
  SemanticsAction::kScrollUp = 1 << 4,
  SemanticsAction::kScrollDown = 1 << 5,
  SemanticsAction::kIncrease = 1 << 6,
  SemanticsAction::kDecrease = 1 << 7,
  SemanticsAction::kShowOnScreen = 1 << 8,
  SemanticsAction::kMoveCursorForwardByCharacter = 1 << 9,
  SemanticsAction::kMoveCursorBackwardByCharacter = 1 << 10,
  SemanticsAction::kSetSelection = 1 << 11,
  SemanticsAction::kCopy = 1 << 12,
  SemanticsAction::kCut = 1 << 13,
  SemanticsAction::kPaste = 1 << 14,
  SemanticsAction::kDidGainAccessibilityFocus = 1 << 15,
  SemanticsAction::kDidLoseAccessibilityFocus = 1 << 16,
  SemanticsAction::kCustomAction = 1 << 17,
  SemanticsAction::kDismiss = 1 << 18,
  SemanticsAction::kMoveCursorForwardByWordIndex = 1 << 19,
  SemanticsAction::kMoveCursorBackwardByWordIndex = 1 << 20,
  SemanticsAction::kSetText = 1 << 21
}
 
enum  SemanticsFlags : int32_t {
  SemanticsFlags::kHasCheckedState = 1 << 0,
  SemanticsFlags::kIsChecked = 1 << 1,
  SemanticsFlags::kIsSelected = 1 << 2,
  SemanticsFlags::kIsButton = 1 << 3,
  SemanticsFlags::kIsTextField = 1 << 4,
  SemanticsFlags::kIsFocused = 1 << 5,
  SemanticsFlags::kHasEnabledState = 1 << 6,
  SemanticsFlags::kIsEnabled = 1 << 7,
  SemanticsFlags::kIsInMutuallyExclusiveGroup = 1 << 8,
  SemanticsFlags::kIsHeader = 1 << 9,
  SemanticsFlags::kIsObscured = 1 << 10,
  SemanticsFlags::kScopesRoute = 1 << 11,
  SemanticsFlags::kNamesRoute = 1 << 12,
  SemanticsFlags::kIsHidden = 1 << 13,
  SemanticsFlags::kIsImage = 1 << 14,
  SemanticsFlags::kIsLiveRegion = 1 << 15,
  SemanticsFlags::kHasToggledState = 1 << 16,
  SemanticsFlags::kIsToggled = 1 << 17,
  SemanticsFlags::kHasImplicitScrolling = 1 << 18,
  SemanticsFlags::kIsReadOnly = 1 << 20,
  SemanticsFlags::kIsFocusable = 1 << 21,
  SemanticsFlags::kIsLink = 1 << 22,
  SemanticsFlags::kIsSlider = 1 << 23,
  SemanticsFlags::kIsKeyboardKey = 1 << 24
}
 
enum  StringAttributeType : int32_t {
  StringAttributeType::kSpellOut,
  StringAttributeType::kLocale
}
 
enum  TextDirection {
  TextDirection::rtl,
  TextDirection::ltr
}
 
enum  KeyEventType : int64_t {
  KeyEventType::kDown = 0,
  KeyEventType::kUp,
  KeyEventType::kRepeat
}
 
enum  AccessibilityFeatureFlag : int32_t {
  AccessibilityFeatureFlag::kAccessibleNavigation = 1 << 0,
  AccessibilityFeatureFlag::kInvertColors = 1 << 1,
  AccessibilityFeatureFlag::kDisableAnimations = 1 << 2,
  AccessibilityFeatureFlag::kBoldText = 1 << 3,
  AccessibilityFeatureFlag::kReduceMotion = 1 << 4,
  AccessibilityFeatureFlag::kHighContrast = 1 << 5
}
 An enum for defining the different kinds of accessibility features that can be enabled by the platform. More...
 
enum  PointerButtonMouse : int64_t {
  kPointerButtonMousePrimary = 1 << 0,
  kPointerButtonMouseSecondary = 1 << 1,
  kPointerButtonMouseMiddle = 1 << 2,
  kPointerButtonMouseBack = 1 << 3,
  kPointerButtonMouseForward = 1 << 4
}
 
enum  PointerButtonTouch : int64_t { kPointerButtonTouchContact = 1 << 0 }
 
enum  PointerButtonStylus : int64_t {
  kPointerButtonStylusContact = 1 << 0,
  kPointerButtonStylusPrimary = 1 << 1,
  kPointerButtonStylusSecondary = 1 << 2
}
 
enum  TracingResult {
  TracingResult::kNotAttempted,
  TracingResult::kEnabled,
  TracingResult::kNotNecessary = kEnabled,
  TracingResult::kDisabled
}
 
enum  ContextType {
  ContextType::kRender,
  ContextType::kResource
}
 
enum  DisplayUpdateType { DisplayUpdateType::kStartup }
 
enum  PipelineConsumeResult {
  PipelineConsumeResult::NoneAvailable,
  PipelineConsumeResult::Done,
  PipelineConsumeResult::MoreAvailable
}
 
enum  DartErrorCode {
  DartErrorCode::NoError = 0,
  DartErrorCode::ApiError = 253,
  DartErrorCode::CompilationError = 254,
  DartErrorCode::UnknownError = 255
}
 Error exit codes for the Dart isolate. More...
 
enum  GpuAvailability {
  GpuAvailability::kAvailable = 0,
  GpuAvailability::kFlushAndMakeUnavailable = 1,
  GpuAvailability::kUnavailable = 2
}
 Values for |Shell::SetGpuAvailability|. More...
 
enum  MTLRenderTargetType {
  MTLRenderTargetType::kMTLTexture,
  MTLRenderTargetType::kCAMetalLayer
}
 
enum  AndroidRenderingAPI {
  AndroidRenderingAPI::kSoftware,
  AndroidRenderingAPI::kOpenGLES
}
 
enum  IOSRenderingAPI {
  IOSRenderingAPI::kSoftware,
  IOSRenderingAPI::kOpenGLES,
  IOSRenderingAPI::kMetal
}
 

Functions

sk_sp< SkData > ParseBase32 (const std::string &input)
 
sk_sp< SkData > ParseBase64 (const std::string &input)
 
static void PersistentCacheStore (fml::RefPtr< fml::TaskRunner > worker, std::shared_ptr< fml::UniqueFD > cache_directory, std::string key, std::unique_ptr< fml::Mapping > value)
 
 DEFINE_DRAW_POINTS_OP (Points, kPoints_PointMode)
 
 DEFINE_DRAW_POINTS_OP (Lines, kLines_PointMode)
 
 DEFINE_DRAW_POINTS_OP (Polygon, kPolygon_PointMode)
 
static void DisposeOps (uint8_t *ptr, uint8_t *end)
 
static bool CompareOps (uint8_t *ptrA, uint8_t *endA, uint8_t *ptrB, uint8_t *endB)
 
static void CopyV (void *dst)
 
template<typename S , typename... Rest>
static void CopyV (void *dst, const S *src, int n, Rest &&... rest)
 
const std::string & GetGoldenDir ()
 
void SetGoldenDir (const std::string &dir)
 
const std::string & GetFontFile ()
 
void SetFontFile (const std::string &file)
 
static std::string ToString (uint64_t val)
 
void DrawCheckerboard (SkCanvas *canvas, SkColor c1, SkColor c2, int size)
 
void DrawCheckerboard (SkCanvas *canvas, const SkRect &rect)
 
static bool CanRasterizeRect (const SkRect &cull_rect)
 
static bool IsPictureWorthRasterizing (SkPicture *picture, bool will_change, bool is_complex)
 
static bool IsDisplayListWorthRasterizing (DisplayList *display_list, bool will_change, bool is_complex)
 
static std::unique_ptr< RasterCacheResultRasterize (GrDirectContext *context, const SkMatrix &ctm, SkColorSpace *dst_color_space, bool checkerboard, const SkRect &logical_rect, const char *type, const std::function< void(SkCanvas *)> &draw_function)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, Scene)
 
static void SceneBuilder_constructor (Dart_NativeArguments args)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, SceneBuilder)
 
 BUILTIN_NATIVE_LIST (DECLARE_FUNCTION)
 
static void PropagateIfError (Dart_Handle result)
 
static Dart_Handle InvokeFunction (Dart_Handle builtin_library, const char *name)
 
static void InitDartInternal (Dart_Handle builtin_library, bool is_ui_isolate)
 
static void InitDartCore (Dart_Handle builtin, const std::string &script_uri)
 
static void InitDartAsync (Dart_Handle builtin_library, bool is_ui_isolate)
 
static void InitDartIO (Dart_Handle builtin_library, const std::string &script_uri)
 
void Logger_PrintDebugString (Dart_NativeArguments args)
 
void Logger_PrintString (Dart_NativeArguments args)
 
void ScheduleMicrotask (Dart_NativeArguments args)
 
static std::string GetFunctionLibraryUrl (Dart_Handle closure)
 
static std::string GetFunctionClassName (Dart_Handle closure)
 
static std::string GetFunctionName (Dart_Handle func)
 
void GetCallbackHandle (Dart_NativeArguments args)
 
void GetCallbackFromHandle (Dart_NativeArguments args)
 
static void Canvas_constructor (Dart_NativeArguments args)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, Canvas)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, Codec)
 
static void ColorFilter_constructor (Dart_NativeArguments args)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, ColorFilter)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, EngineLayer)
 
static void FragmentProgram_constructor (Dart_NativeArguments args)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, FragmentProgram)
 
static void Gradient_constructor (Dart_NativeArguments args)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, Gradient)
 
static sk_sp< SkImage > ResizeRasterImage (sk_sp< SkImage > image, const SkISize &resized_dimensions, const fml::tracing::TraceFlow &flow)
 
static sk_sp< SkImage > ImageFromDecompressedData (ImageDescriptor *descriptor, uint32_t target_width, uint32_t target_height, const fml::tracing::TraceFlow &flow)
 
sk_sp< SkImage > ImageFromCompressedData (ImageDescriptor *descriptor, uint32_t target_width, uint32_t target_height, const fml::tracing::TraceFlow &flow)
 
static SkiaGPUObject< SkImage > UploadRasterImage (sk_sp< SkImage > image, fml::WeakPtr< IOManager > io_manager, const fml::tracing::TraceFlow &flow)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, ImageDescriptor)
 
Dart_Handle EncodeImage (CanvasImage *canvas_image, int format, Dart_Handle callback_handle)
 
template<typename SyncSwitch >
sk_sp< SkImage > ConvertToRasterUsingResourceContext (sk_sp< SkImage > image, fml::WeakPtr< GrDirectContext > resource_context, const std::shared_ptr< const SyncSwitch > &is_gpu_disabled_sync_switch)
 
static void ImageFilter_constructor (Dart_NativeArguments args)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, ImageFilter)
 
static void ImageShader_constructor (Dart_NativeArguments args)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, ImageShader)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, ImmutableBuffer)
 
SkMatrix ToSkMatrix (const tonic::Float64List &matrix4)
 
tonic::Float64List ToMatrix4 (const SkMatrix &sk_matrix)
 
static void InvokeNextFrameCallback (fml::RefPtr< CanvasImage > image, int duration, std::unique_ptr< DartPersistentValue > callback, size_t trace_id)
 
static bool CopyToBitmap (SkBitmap *dst, SkColorType dstColorType, const SkBitmap &src)
 
static void Path_constructor (Dart_NativeArguments args)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, Path)
 
static void PathMeasure_constructor (Dart_NativeArguments args)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, PathMeasure)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, Picture)
 
static void PictureRecorder_constructor (Dart_NativeArguments args)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, PictureRecorder)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, Shader)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, Vertices)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, SemanticsUpdate)
 
void pushStringAttributes (StringAttributes &destination, const std::vector< NativeStringAttribute *> &native_attributes)
 
static void SemanticsUpdateBuilder_constructor (Dart_NativeArguments args)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, SemanticsUpdateBuilder)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, NativeStringAttribute)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, Paragraph)
 
static tonic::Float32List EncodeTextBoxes (const std::vector< txt::Paragraph::TextBox > &boxes)
 
static void ParagraphBuilder_constructor (Dart_NativeArguments args)
 
 IMPLEMENT_WRAPPERTYPEINFO (ui, ParagraphBuilder)
 
void decodeStrut (Dart_Handle strut_data, const std::vector< std::string > &strut_font_families, txt::ParagraphStyle &paragraph_style)
 
void decodeTextShadows (Dart_Handle shadows_data, std::vector< txt::TextShadow > &decoded_shadows)
 
void decodeFontFeatures (Dart_Handle font_features_data, txt::FontFeatures &font_features)
 
static void BM_PlatformMessageResponseDartComplete (benchmark::State &state)
 
static void BM_PathVolatilityTracker (benchmark::State &state)
 
 Unit (benchmark::kMicrosecond)
 
 BENCHMARK (BM_PathVolatilityTracker) -> Unit(benchmark::kMillisecond)
 
Dart_Handle ComputePlatformResolvedLocale (Dart_Handle supportedLocalesHandle)
 
static void _ComputePlatformResolvedLocale (Dart_NativeArguments args)
 
bool operator== (const ViewportMetrics &a, const ViewportMetrics &b)
 
std::ostream & operator<< (std::ostream &os, const ViewportMetrics &a)
 
static bool InvokeMainEntrypoint (Dart_Handle user_entrypoint_function, Dart_Handle args)
 
static void InvokeDartPluginRegistrantIfAvailable (Dart_Handle library_handle)
 
 TEST (DartServiceIsolateTest, CanAddAndRemoveHandles)
 
static std::unique_ptr< const fml::MappingGetFileMapping (const std::string &path, bool executable)
 
static std::shared_ptr< const fml::MappingSearchMapping (MappingCallback embedder_mapping_callback, const std::string &file_path, const std::vector< std::string > &native_library_path, const char *native_library_symbol_name, bool is_executable)
 
static std::shared_ptr< const fml::MappingResolveVMData (const Settings &settings)
 
static std::shared_ptr< const fml::MappingResolveVMInstructions (const Settings &settings)
 
static std::shared_ptr< const fml::MappingResolveIsolateData (const Settings &settings)
 
static std::shared_ptr< const fml::MappingResolveIsolateInstructions (const Settings &settings)
 
static std::string DartOldGenHeapSizeArgs (uint64_t heap_size)
 
bool DartFileModifiedCallback (const char *source_url, int64_t since_ms)
 
void ThreadExitCallback ()
 
Dart_Handle GetVMServiceAssetsArchiveCallback ()
 
static bool ServiceStreamListenCallback (const char *stream_id)
 
static void ServiceStreamCancelCallback (const char *stream_id)
 
static std::vector< const char * > ProfilingFlags (bool enable_profiling)
 
void PushBackAll (std::vector< const char *> *args, const char **argv, size_t argc)
 
static void EmbedderInformationCallback (Dart_EmbedderInformation *info)
 
static std::vector< std::string > ParseKernelListPaths (std::unique_ptr< fml::Mapping > kernel_list)
 
static std::vector< std::future< std::unique_ptr< const fml::Mapping > > > PrepareKernelMappings (std::vector< std::string > kernel_pieces_paths, std::shared_ptr< AssetManager > asset_manager, fml::RefPtr< fml::TaskRunner > io_worker)
 
bool EnableTracingIfNecessary (const Settings &vm_settings)
 Enables tracing in the process so that JIT mode VMs may be launched. Explicitly enabling tracing is not required on all platforms. On platforms where it is not required, calling this method will return true. If tracing is required but cannot be enabled, it is the responsibility of the caller to display the appropriate error message to the user as subsequent attempts to launch the VM in JIT mode will cause process termination. More...
 
TracingResult GetTracingResult ()
 Returns if a tracing check has been performed and its result. To enable tracing, the Settings object used to launch the VM is required. Components may want to display messages based on the result of a previous tracing check without actually having the settings object. This accessor can be used instead. More...
 
static void WriteServerErrorResponse (rapidjson::Document *document, const char *message)
 
static bool HandleMessageOnHandler (ServiceProtocol::Handler *handler, std::string_view method, const ServiceProtocol::Handler::ServiceProtocolMap &params, rapidjson::Document *document)
 
static std::string CreateFlutterViewID (intptr_t handler)
 
static std::string CreateIsolateID (int64_t isolate)
 
std::vector< std::unique_ptr< SkStreamAsset > > GetTestFontData ()
 
std::string GetTestFontFamilyName ()
 
std::vector< std::string > GetTestFontFamilyNames ()
 
static fml::TimePoint FxlToDartOrEarlier (fml::TimePoint time)
 
GrContextOptions MakeDefaultContextOptions (ContextType type, std::optional< GrBackendApi > api=std::nullopt)
 Initializes GrContextOptions with values suitable for Flutter. The options can be further tweaked before a GrContext is created from these options. More...
 
 TEST_F (EngineTest, Create)
 
 TEST_F (EngineTest, DispatchPlatformMessageUnknown)
 
 TEST_F (EngineTest, DispatchPlatformMessageInitialRoute)
 
 TEST_F (EngineTest, DispatchPlatformMessageInitialRouteIgnored)
 
 TEST_F (EngineTest, SpawnSharesFontLibrary)
 
 TEST_F (EngineTest, SpawnWithCustomInitialRoute)
 
 TEST_F (EngineTest, SpawnResetsViewportMetrics)
 
 TEST_F (EngineTest, PassesLoadDartDeferredLibraryErrorToRuntime)
 
size_t GetNextPipelineTraceID ()
 
static constexpr std::chrono::milliseconds kSkiaCleanupExpiration (15000)
 
static sk_sp< SkData > ScreenshotLayerTreeAsPicture (flutter::LayerTree *tree, flutter::CompositorContext &compositor_context)
 
static sk_sp< SkSurface > CreateSnapshotSurface (GrDirectContext *surface_context, const SkISize &size)
 
 TEST (RasterizerTest, create)
 
static std::unique_ptr< FrameTimingsRecorderCreateFinishedBuildRecorder ()
 
 TEST (RasterizerTest, drawEmptyPipeline)
 
 TEST (RasterizerTest, drawWithExternalViewEmbedderExternalViewEmbedderSubmitFrameCalled)
 
 TEST (RasterizerTest, drawWithExternalViewEmbedderAndThreadMergerNotMergedExternalViewEmbedderSubmitFrameNotCalled)
 
 TEST (RasterizerTest, drawWithExternalViewEmbedderAndThreadsMergedExternalViewEmbedderSubmitFrameCalled)
 
 TEST (RasterizerTest, externalViewEmbedderDoesntEndFrameWhenNoSurfaceIsSet)
 
 TEST (RasterizerTest, drawWithGpuEnabledAndSurfaceAllowsDrawingWhenGpuDisabledDoesAcquireFrame)
 
 TEST (RasterizerTest, drawWithGpuDisabledAndSurfaceAllowsDrawingWhenGpuDisabledDoesAcquireFrame)
 
 TEST (RasterizerTest, drawWithGpuEnabledAndSurfaceDisallowsDrawingWhenGpuDisabledDoesAcquireFrame)
 
 TEST (RasterizerTest, drawWithGpuDisabledAndSurfaceDisallowsDrawingWhenGpuDisabledDoesntAcquireFrame)
 
sk_sp< SkData > SerializeTypefaceWithoutData (SkTypeface *typeface, void *ctx)
 
sk_sp< SkData > SerializeTypefaceWithData (SkTypeface *typeface, void *ctx)
 
sk_sp< SkTypeface > DeserializeTypefaceWithoutData (const void *data, size_t length, void *ctx)
 
struct flutter::ImageMetaData __attribute__ ((packed))
 
sk_sp< SkData > SerializeImageWithoutData (SkImage *image, void *ctx)
 
sk_sp< SkImage > DeserializeImageWithoutData (const void *data, size_t length, void *ctx)
 
static void ServiceProtocolParameterError (rapidjson::Document *response, std::string error_details)
 
static void ServiceProtocolFailureError (rapidjson::Document *response, std::string message)
 
static void StartupAndShutdownShell (benchmark::State &state, bool measure_startup, bool measure_shutdown)
 
static void BM_ShellInitialization (benchmark::State &state)
 
 BENCHMARK (BM_ShellInitialization)
 
static void BM_ShellShutdown (benchmark::State &state)
 
 BENCHMARK (BM_ShellShutdown)
 
static void BM_ShellInitializationAndShutdown (benchmark::State &state)
 
 BENCHMARK (BM_ShellInitializationAndShutdown)
 
void InitSkiaEventTracer (bool enabled, const std::optional< std::vector< std::string >> &allowlist)
 
void PrintUsage (const std::string &executable_name)
 
const std::string_view FlagForSwitch (Switch swtch)
 
static std::vector< std::string > ParseCommaDelimited (const std::string &input)
 
static bool IsAllowedDartVMFlag (const std::string &flag)
 
template<typename T >
static bool GetSwitchValue (const fml::CommandLine &command_line, Switch sw, T *result)
 
std::unique_ptr< fml::MappingGetSymbolMapping (std::string symbol_prefix, std::string native_lib_path)
 
Settings SettingsFromCommandLine (const fml::CommandLine &command_line)
 
DEF_SWITCHES_START DEF_SWITCH (AotSharedLibraryName, "aot-shared-library-name", "Name of the *.so containing AOT compiled Dart assets.") DEF_SWITCH(AotVMServiceSharedLibraryName
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate DEF_SWITCH (SnapshotAssetPath, "snapshot-asset-path", "Path to the directory containing the four files specified by " "VmSnapshotData, VmSnapshotInstructions, " "VmSnapshotInstructions and IsolateSnapshotInstructions.") DEF_SWITCH(VmSnapshotData
 
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 DEF_SWITCH (VmSnapshotInstructions, "vm-snapshot-instr", "The VM instructions snapshot that will be memory mapped as read " "and executable. SnapshotAssetPath must be present.") DEF_SWITCH(IsolateSnapshotData
 
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 DEF_SWITCH (IsolateSnapshotInstructions, "isolate-snapshot-instr", "The isolate instructions snapshot that will be memory mapped as " "read and executable. SnapshotAssetPath must be present.") DEF_SWITCH(CacheDirPath
 
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 DEF_SWITCH (ICUSymbolPrefix, "icu-symbol-prefix", "Prefix for the symbols representing ICU data linked into the " "Flutter library.") DEF_SWITCH(ICUNativeLibPath
 
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 DEF_SWITCH (DartFlags, "dart-flags", "Flags passed directly to the Dart VM without being interpreted " "by the Flutter shell.") DEF_SWITCH(DeviceObservatoryHost
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified DEF_SWITCH (DeviceObservatoryPort, "observatory-port", "A custom Dart Observatory port. The default is to pick a randomly " "available open port.") DEF_SWITCH(DisableObservatory
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode DEF_SWITCH (DisableObservatoryPublication, "disable-observatory-publication", "Disable mDNS Dart Observatory publication.") DEF_SWITCH(IPv6
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set DEF_SWITCH (EnableDartProfiling, "enable-dart-profiling", "Enable Dart profiling. Profiling information can be viewed from " "the observatory.") DEF_SWITCH(EndlessTraceBuffer
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however DEF_SWITCH (EnableSoftwareRendering, "enable-software-rendering", "Enable rendering using the Skia software backend. This is useful " "when testing Flutter on emulators. By default, Flutter will " "attempt to either use OpenGL, Metal, or Vulkan.") DEF_SWITCH(SkiaDeterministicRendering
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however skia deterministic Skips the call to thus avoiding swapping out some Skia function pointers based on available CPU features This is used to obtain deterministic behavior in Skia rendering DEF_SWITCH (FlutterAssetsDir, "flutter-assets-dir", "Path to the Flutter assets directory.") DEF_SWITCH(DisableServiceAuthCodes
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however skia deterministic Skips the call to thus avoiding swapping out some Skia function pointers based on available CPU features This is used to obtain deterministic behavior in Skia rendering disable service auth Disable the requirement for authentication codes for communicating with the VM service DEF_SWITCH (EnableServicePortFallback, "enable-service-port-fallback", "Allow the VM service to fallback to automatic port selection if" " binding to a specified port fails.") DEF_SWITCH(StartPaused
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however skia deterministic Skips the call to thus avoiding swapping out some Skia function pointers based on available CPU features This is used to obtain deterministic behavior in Skia rendering disable service auth Disable the requirement for authentication codes for communicating with the VM service start Start the application paused in the Dart debugger DEF_SWITCH (TraceStartup, "trace-startup", "Trace early application lifecycle. Automatically switches to an " "endless trace buffer.") DEF_SWITCH(TraceSkia
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however skia deterministic Skips the call to thus avoiding swapping out some Skia function pointers based on available CPU features This is used to obtain deterministic behavior in Skia rendering disable service auth Disable the requirement for authentication codes for communicating with the VM service start Start the application paused in the Dart debugger trace Trace Skia calls This is useful when debugging the GPU threed By Skia tracing is not enabled to reduce the number of traced events DEF_SWITCH (TraceSkiaAllowlist, "trace-skia-allowlist", "Filters out all Skia trace event categories except those that are " "specified in this comma separated list.") DEF_SWITCH(TraceAllowlist
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however skia deterministic Skips the call to thus avoiding swapping out some Skia function pointers based on available CPU features This is used to obtain deterministic behavior in Skia rendering disable service auth Disable the requirement for authentication codes for communicating with the VM service start Start the application paused in the Dart debugger trace Trace Skia calls This is useful when debugging the GPU threed By Skia tracing is not enabled to reduce the number of traced events trace Filters out all trace events except those that are specified in this comma separated list of allowed prefixes DEF_SWITCH (DumpSkpOnShaderCompilation, "dump-skp-on-shader-compilation", "Automatically dump the skp that triggers new shader compilations. " "This is useful for writing custom ShaderWarmUp to reduce jank. " "By default, this is not enabled to reduce the overhead. ") DEF_SWITCH(CacheSkSL
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however skia deterministic Skips the call to thus avoiding swapping out some Skia function pointers based on available CPU features This is used to obtain deterministic behavior in Skia rendering disable service auth Disable the requirement for authentication codes for communicating with the VM service start Start the application paused in the Dart debugger trace Trace Skia calls This is useful when debugging the GPU threed By Skia tracing is not enabled to reduce the number of traced events trace Filters out all trace events except those that are specified in this comma separated list of allowed prefixes cache Only cache the shader in SkSL instead of binary or GLSL This should only be used during development phases The generated SkSLs can later be used in the release build for shader precompilation at launch in order to eliminate the shader compile jank DEF_SWITCH (PurgePersistentCache, "purge-persistent-cache", "Remove all existing persistent cache. This is mainly for debugging " "purposes such as reproducing the shader compilation jank.") DEF_SWITCH(TraceSystrace
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however skia deterministic Skips the call to thus avoiding swapping out some Skia function pointers based on available CPU features This is used to obtain deterministic behavior in Skia rendering disable service auth Disable the requirement for authentication codes for communicating with the VM service start Start the application paused in the Dart debugger trace Trace Skia calls This is useful when debugging the GPU threed By Skia tracing is not enabled to reduce the number of traced events trace Filters out all trace events except those that are specified in this comma separated list of allowed prefixes cache Only cache the shader in SkSL instead of binary or GLSL This should only be used during development phases The generated SkSLs can later be used in the release build for shader precompilation at launch in order to eliminate the shader compile jank trace Trace to the system tracer (instead of the timeline) on platforms where " "such a tracer is available. Currently only supported on Android and " "Fuchsia.") DEF_SWITCH(UseTestFonts
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however skia deterministic Skips the call to thus avoiding swapping out some Skia function pointers based on available CPU features This is used to obtain deterministic behavior in Skia rendering disable service auth Disable the requirement for authentication codes for communicating with the VM service start Start the application paused in the Dart debugger trace Trace Skia calls This is useful when debugging the GPU threed By Skia tracing is not enabled to reduce the number of traced events trace Filters out all trace events except those that are specified in this comma separated list of allowed prefixes cache Only cache the shader in SkSL instead of binary or GLSL This should only be used during development phases The generated SkSLs can later be used in the release build for shader precompilation at launch in order to eliminate the shader compile jank trace Trace to the system use test Running tests that layout and measure text will not yield consistent results across various platforms Enabling this option will make font resolution default to the Ahem test font on all platforms (See https:"This option is only available on the desktop test shells.") DEF_SWITCH(PrefetchedDefaultFontManager
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however skia deterministic Skips the call to thus avoiding swapping out some Skia function pointers based on available CPU features This is used to obtain deterministic behavior in Skia rendering disable service auth Disable the requirement for authentication codes for communicating with the VM service start Start the application paused in the Dart debugger trace Trace Skia calls This is useful when debugging the GPU threed By Skia tracing is not enabled to reduce the number of traced events trace Filters out all trace events except those that are specified in this comma separated list of allowed prefixes cache Only cache the shader in SkSL instead of binary or GLSL This should only be used during development phases The generated SkSLs can later be used in the release build for shader precompilation at launch in order to eliminate the shader compile jank trace Trace to the system use test Running tests that layout and measure text will not yield consistent results across various platforms Enabling this option will make font resolution default to the Ahem test font on all prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine DEF_SWITCH (VerboseLogging, "verbose-logging", "By default, only errors are logged. This flag enabled logging at " "all severity levels. This is NOT a per shell flag and affect log " "levels for all shells in the process.") DEF_SWITCH(RunForever
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however skia deterministic Skips the call to thus avoiding swapping out some Skia function pointers based on available CPU features This is used to obtain deterministic behavior in Skia rendering disable service auth Disable the requirement for authentication codes for communicating with the VM service start Start the application paused in the Dart debugger trace Trace Skia calls This is useful when debugging the GPU threed By Skia tracing is not enabled to reduce the number of traced events trace Filters out all trace events except those that are specified in this comma separated list of allowed prefixes cache Only cache the shader in SkSL instead of binary or GLSL This should only be used during development phases The generated SkSLs can later be used in the release build for shader precompilation at launch in order to eliminate the shader compile jank trace Trace to the system use test Running tests that layout and measure text will not yield consistent results across various platforms Enabling this option will make font resolution default to the Ahem test font on all prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive keep the shell running after the Dart script has completed DEF_SWITCH (DisableDartAsserts, "disable-dart-asserts", "Dart code runs with assertions enabled when the runtime mode is " "debug. In profile and release product modes, assertions are " "disabled. This flag may be specified if the user wishes to run " "with assertions disabled in the debug product mode (i.e. with JIT " "or DBC).") DEF_SWITCH(DisallowInsecureConnections
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however skia deterministic Skips the call to thus avoiding swapping out some Skia function pointers based on available CPU features This is used to obtain deterministic behavior in Skia rendering disable service auth Disable the requirement for authentication codes for communicating with the VM service start Start the application paused in the Dart debugger trace Trace Skia calls This is useful when debugging the GPU threed By Skia tracing is not enabled to reduce the number of traced events trace Filters out all trace events except those that are specified in this comma separated list of allowed prefixes cache Only cache the shader in SkSL instead of binary or GLSL This should only be used during development phases The generated SkSLs can later be used in the release build for shader precompilation at launch in order to eliminate the shader compile jank trace Trace to the system use test Running tests that layout and measure text will not yield consistent results across various platforms Enabling this option will make font resolution default to the Ahem test font on all prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive keep the shell running after the Dart script has completed disallow insecure By all insecure connections are rejected DEF_SWITCH (DomainNetworkPolicy, "domain-network-policy", "JSON encoded network policy per domain. This overrides the " "DisallowInsecureConnections switch. Embedder can specify whether " "to allow or disallow insecure connections at a domain level.") DEF_SWITCH(ForceMultithreading
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however skia deterministic Skips the call to thus avoiding swapping out some Skia function pointers based on available CPU features This is used to obtain deterministic behavior in Skia rendering disable service auth Disable the requirement for authentication codes for communicating with the VM service start Start the application paused in the Dart debugger trace Trace Skia calls This is useful when debugging the GPU threed By Skia tracing is not enabled to reduce the number of traced events trace Filters out all trace events except those that are specified in this comma separated list of allowed prefixes cache Only cache the shader in SkSL instead of binary or GLSL This should only be used during development phases The generated SkSLs can later be used in the release build for shader precompilation at launch in order to eliminate the shader compile jank trace Trace to the system use test Running tests that layout and measure text will not yield consistent results across various platforms Enabling this option will make font resolution default to the Ahem test font on all prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive keep the shell running after the Dart script has completed disallow insecure By all insecure connections are rejected force Uses separate threads for the GPU and IO task runners By a single thread is used for all task runners Only available in the flutter_tester DEF_SWITCH (OldGenHeapSize, "old-gen-heap-size", "The size limit in megabytes for the Dart VM old gen heap space.") DEF_SWITCH(EnableSkParagraph
 
static SkColorType FirstSupportedColorType (GrDirectContext *context, GrGLenum *format)
 
static sk_sp< SkSurface > WrapOnscreenSurface (GrDirectContext *context, const SkISize &size, intptr_t fbo)
 
static bool IsProcResolverOpenGLES (GPUSurfaceGLDelegate::GLProcResolver proc_resolver)
 
static sk_sp< const GrGLInterface > CreateGLInterface (GPUSurfaceGLDelegate::GLProcResolver proc_resolver)
 
static void LogLastEGLError ()
 
static EGLResult< EGLContext > CreateContext (EGLDisplay display, EGLConfig config, EGLContext share=EGL_NO_CONTEXT)
 
static EGLResult< EGLConfig > ChooseEGLConfiguration (EGLDisplay display)
 
static bool TeardownContext (EGLDisplay display, EGLContext context)
 
static PlatformData GetDefaultPlatformData ()
 
static void PrefetchDefaultFontManager (JNIEnv *env, jclass jcaller)
 
static std::shared_ptr< flutter::AndroidContextCreateAndroidContext (bool use_software_rendering, const flutter::TaskRunners task_runners)
 
void putStringAttributesIntoBuffer (const StringAttributes &attributes, int32_t *buffer_int32, size_t &position, std::vector< std::vector< uint8_t >> &string_attribute_args)
 
jobject CreateFlutterCallbackInformation (JNIEnv *env, const std::string &callbackName, const std::string &callbackClassName, const std::string &callbackLibraryPath)
 
static jlong AttachJNI (JNIEnv *env, jclass clazz, jobject flutterJNI)
 
static void DestroyJNI (JNIEnv *env, jobject jcaller, jlong shell_holder)
 
static jobject SpawnJNI (JNIEnv *env, jobject jcaller, jlong shell_holder, jstring jEntrypoint, jstring jLibraryUrl, jstring jInitialRoute, jobject jEntrypointArgs)
 
static void SurfaceCreated (JNIEnv *env, jobject jcaller, jlong shell_holder, jobject jsurface)
 
static void SurfaceWindowChanged (JNIEnv *env, jobject jcaller, jlong shell_holder, jobject jsurface)
 
static void SurfaceChanged (JNIEnv *env, jobject jcaller, jlong shell_holder, jint width, jint height)
 
static void SurfaceDestroyed (JNIEnv *env, jobject jcaller, jlong shell_holder)
 
static void RunBundleAndSnapshotFromLibrary (JNIEnv *env, jobject jcaller, jlong shell_holder, jstring jBundlePath, jstring jEntrypoint, jstring jLibraryUrl, jobject jAssetManager, jobject jEntrypointArgs)
 
static jobject LookupCallbackInformation (JNIEnv *env, jobject, jlong handle)
 
static void SetViewportMetrics (JNIEnv *env, jobject jcaller, jlong shell_holder, jfloat devicePixelRatio, jint physicalWidth, jint physicalHeight, jint physicalPaddingTop, jint physicalPaddingRight, jint physicalPaddingBottom, jint physicalPaddingLeft, jint physicalViewInsetTop, jint physicalViewInsetRight, jint physicalViewInsetBottom, jint physicalViewInsetLeft, jint systemGestureInsetTop, jint systemGestureInsetRight, jint systemGestureInsetBottom, jint systemGestureInsetLeft, jint physicalTouchSlop, jintArray javaDisplayFeaturesBounds, jintArray javaDisplayFeaturesType, jintArray javaDisplayFeaturesState)
 
static jobject GetBitmap (JNIEnv *env, jobject jcaller, jlong shell_holder)
 
static void DispatchPlatformMessage (JNIEnv *env, jobject jcaller, jlong shell_holder, jstring channel, jobject message, jint position, jint responseId)
 
static void DispatchEmptyPlatformMessage (JNIEnv *env, jobject jcaller, jlong shell_holder, jstring channel, jint responseId)
 
static void CleanupMessageData (JNIEnv *env, jobject jcaller, jlong message_data)
 
static void DispatchPointerDataPacket (JNIEnv *env, jobject jcaller, jlong shell_holder, jobject buffer, jint position)
 
static void DispatchSemanticsAction (JNIEnv *env, jobject jcaller, jlong shell_holder, jint id, jint action, jobject args, jint args_position)
 
static void SetSemanticsEnabled (JNIEnv *env, jobject jcaller, jlong shell_holder, jboolean enabled)
 
static void SetAccessibilityFeatures (JNIEnv *env, jobject jcaller, jlong shell_holder, jint flags)
 
static jboolean GetIsSoftwareRendering (JNIEnv *env, jobject jcaller)
 
static void RegisterTexture (JNIEnv *env, jobject jcaller, jlong shell_holder, jlong texture_id, jobject surface_texture)
 
static void MarkTextureFrameAvailable (JNIEnv *env, jobject jcaller, jlong shell_holder, jlong texture_id)
 
static void UnregisterTexture (JNIEnv *env, jobject jcaller, jlong shell_holder, jlong texture_id)
 
static void InvokePlatformMessageResponseCallback (JNIEnv *env, jobject jcaller, jlong shell_holder, jint responseId, jobject message, jint position)
 
static void InvokePlatformMessageEmptyResponseCallback (JNIEnv *env, jobject jcaller, jlong shell_holder, jint responseId)
 
static void NotifyLowMemoryWarning (JNIEnv *env, jobject obj, jlong shell_holder)
 
static jboolean FlutterTextUtilsIsEmoji (JNIEnv *env, jobject obj, jint codePoint)
 
static jboolean FlutterTextUtilsIsEmojiModifier (JNIEnv *env, jobject obj, jint codePoint)
 
static jboolean FlutterTextUtilsIsEmojiModifierBase (JNIEnv *env, jobject obj, jint codePoint)
 
static jboolean FlutterTextUtilsIsVariationSelector (JNIEnv *env, jobject obj, jint codePoint)
 
static jboolean FlutterTextUtilsIsRegionalIndicator (JNIEnv *env, jobject obj, jint codePoint)
 
static void LoadLoadingUnitFailure (intptr_t loading_unit_id, std::string message, bool transient)
 
static void DeferredComponentInstallFailure (JNIEnv *env, jobject obj, jint jLoadingUnitId, jstring jError, jboolean jTransient)
 
static void LoadDartDeferredLibrary (JNIEnv *env, jobject obj, jlong shell_holder, jint jLoadingUnitId, jobjectArray jSearchPaths)
 
static void UpdateJavaAssetManager (JNIEnv *env, jobject obj, jlong shell_holder, jobject jAssetManager, jstring jAssetBundlePath)
 
bool RegisterApi (JNIEnv *env)
 
SkSize ScaleToFill (float scaleX, float scaleY)
 
 TEST (BasicMessageChannelTest, Registration)
 
 TEST (BasicMessageChannelTest, Unregistration)
 
 TEST (EncodableValueTest, Null)
 
 TEST (EncodableValueTest, Bool)
 
 TEST (EncodableValueTest, Int)
 
 TEST (EncodableValueTest, LongValue)
 
 TEST (EncodableValueTest, Long)
 
 TEST (EncodableValueTest, Double)
 
 TEST (EncodableValueTest, String)
 
 TEST (EncodableValueTest, CString)
 
 TEST (EncodableValueTest, UInt8List)
 
 TEST (EncodableValueTest, Int32List)
 
 TEST (EncodableValueTest, Int64List)
 
 TEST (EncodableValueTest, DoubleList)
 
 TEST (EncodableValueTest, List)
 
 TEST (EncodableValueTest, Map)
 
 TEST (EncodableValueTest, Comparison)
 
 TEST (EncodableValueTest, DeepCopy)
 
 TEST (EncodableValueTest, TypeIndexesCorrect)
 
 TEST (EventChannelTest, Registration)
 
 TEST (EventChannelTest, Unregistration)
 
 TEST (EventChannelTest, Cancel)
 
 TEST (EventChannelTest, ListenNotCancel)
 
 TEST (EventChannelTest, ReRegistration)
 
 TEST (MethodCallTest, Basic)
 
 TEST (MethodChannelTest, Registration)
 
 TEST (MethodChannelTest, Unregistration)
 
 TEST (MethodChannelTest, InvokeWithoutResponse)
 
 TEST (MethodChannelTest, InvokeWithResponse)
 
 TEST (MethodChannelTest, InvokeNotImplemented)
 
 TEST (MethodChannelTest, NoHandlers)
 
 TEST (MethodChannelTest, Success)
 
 TEST (MethodChannelTest, Error)
 
 TEST (MethodChannelTest, NotImplemented)
 
 TEST (PluginRegistrarTest, PluginDestroyedBeforeRegistrar)
 
 TEST (PluginRegistrarTest, MessengerSend)
 
 TEST (PluginRegistrarTest, MessengerSetMessageHandler)
 
 TEST (PluginRegistrarTest, ManagerSameInstance)
 
 TEST (PluginRegistrarTest, ManagerDifferentInstances)
 
 TEST (PluginRegistrarTest, ManagerRemovesOnDestruction)
 
 TEST (PluginRegistrarTest, TextureRegistrarNotNull)
 
static void CheckEncodeDecode (const EncodableValue &value, const std::vector< uint8_t > &expected_encoding, const StandardCodecSerializer *serializer=nullptr, std::function< bool(const EncodableValue &a, const EncodableValue &b)> custom_comparator=nullptr)
 
static void CheckEncodeDecodeWithEncodePrefix (const EncodableValue &value, const std::vector< uint8_t > &expected_encoding_prefix, size_t expected_encoding_length)
 
 TEST (StandardMessageCodec, GetInstanceCachesInstance)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeNull)
 
 TEST (StandardMessageCodec, CanDecodeEmptyBytesAsNullWithoutCallingSerializer)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeTrue)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeFalse)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeInt32)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeInt64)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeDouble)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeString)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeStringWithNonAsciiCodePoint)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeStringWithNonBMPCodePoint)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeEmptyString)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeList)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeEmptyList)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeMap)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeByteArray)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeInt32Array)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeInt64Array)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeFloat32Array)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeFloat64Array)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeSimpleCustomType)
 
 TEST (StandardMessageCodec, CanEncodeAndDecodeVariableLengthCustomType)
 
 TEST (StandardMethodCodec, GetInstanceCachesInstance)
 
 TEST (StandardMethodCodec, HandlesMethodCallsWithNullArguments)
 
 TEST (StandardMethodCodec, HandlesMethodCallsWithArgument)
 
 TEST (StandardMethodCodec, HandlesSuccessEnvelopesWithNullResult)
 
 TEST (StandardMethodCodec, HandlesSuccessEnvelopesWithResult)
 
 TEST (StandardMethodCodec, HandlesErrorEnvelopesWithNulls)
 
 TEST (StandardMethodCodec, HandlesErrorEnvelopesWithDetails)
 
 TEST (StandardMethodCodec, HandlesCustomTypeArguments)
 
 TEST (TextureRegistrarTest, RegisterUnregisterTexture)
 
 TEST (TextureRegistrarTest, UnregisterInvalidTexture)
 
 TEST (TextureRegistrarTest, MarkFrameAvailableInvalidTexture)
 
std::vector< std::string > GetSwitchesFromEnvironment ()
 
 TEST (FlutterProjectBundle, SwitchesEmpty)
 
 TEST (FlutterProjectBundle, Switches)
 
 TEST (FlutterProjectBundle, SwitchesExtraValues)
 
 TEST (FlutterProjectBundle, SwitchesMissingValues)
 
 TEST (Point, SetsCoordinates)
 
 TEST (Size, SetsDimensions)
 
 TEST (Size, ClampsDimensionsPositive)
 
 TEST (Rect, SetsOriginAndSize)
 
 TEST (Rect, ReturnsLTRB)
 
 TEST (Rect, ReturnsWidthHeight)
 
 TEST (JsonMessageCodec, EncodeDecode)
 
 TEST (JsonMethodCodec, HandlesMethodCallsWithNullArguments)
 
 TEST (JsonMethodCodec, HandlesMethodCallsWithArgument)
 
 TEST (JsonMethodCodec, HandlesSuccessEnvelopesWithNullResult)
 
 TEST (JsonMethodCodec, HandlesSuccessEnvelopesWithResult)
 
 TEST (JsonMethodCodec, HandlesErrorEnvelopesWithNulls)
 
 TEST (JsonMethodCodec, HandlesErrorEnvelopesWithDetails)
 
std::filesystem::path GetExecutableDirectory ()
 
 TEST (PathUtilsTest, ExecutableDirector)
 
 TEST (TextEditingDeltaTest, TestTextEditingDeltaConstructor)
 
 TEST (TextEditingDeltaTest, TestTextEditingDeltaNonTextConstructor)
 
 TEST (TextInputModel, SetText)
 
 TEST (TextInputModel, SetTextWideCharacters)
 
 TEST (TextInputModel, SetTextEmpty)
 
 TEST (TextInputModel, SetTextReplaceText)
 
 TEST (TextInputModel, SetTextResetsSelection)
 
 TEST (TextInputModel, SetSelectionStart)
 
 TEST (TextInputModel, SetSelectionComposingStart)
 
 TEST (TextInputModel, SetSelectionMiddle)
 
 TEST (TextInputModel, SetSelectionComposingMiddle)
 
 TEST (TextInputModel, SetSelectionEnd)
 
 TEST (TextInputModel, SetSelectionComposingEnd)
 
 TEST (TextInputModel, SetSelectionWthExtent)
 
 TEST (TextInputModel, SetSelectionWthExtentComposing)
 
 TEST (TextInputModel, SetSelectionReverseExtent)
 
 TEST (TextInputModel, SetSelectionReverseExtentComposing)
 
 TEST (TextInputModel, SetSelectionOutsideString)
 
 TEST (TextInputModel, SetSelectionOutsideComposingRange)
 
 TEST (TextInputModel, SetComposingRangeStart)
 
 TEST (TextInputModel, SetComposingRangeMiddle)
 
 TEST (TextInputModel, SetComposingRangeEnd)
 
 TEST (TextInputModel, SetComposingRangeWithExtent)
 
 TEST (TextInputModel, SetComposingRangeReverseExtent)
 
 TEST (TextInputModel, SetComposingRangeOutsideString)
 
 TEST (TextInputModel, CommitComposingNoTextWithNoSelection)
 
 TEST (TextInputModel, CommitComposingNoTextWithSelection)
 
 TEST (TextInputModel, CommitComposingTextWithNoSelection)
 
 TEST (TextInputModel, CommitComposingTextWithSelection)
 
 TEST (TextInputModel, UpdateComposingRemovesLastComposingCharacter)
 
 TEST (TextInputModel, AddCodePoint)
 
 TEST (TextInputModel, AddCodePointSelection)
 
 TEST (TextInputModel, AddCodePointReverseSelection)
 
 TEST (TextInputModel, AddCodePointSelectionWideCharacter)
 
 TEST (TextInputModel, AddCodePointReverseSelectionWideCharacter)
 
 TEST (TextInputModel, AddText)
 
 TEST (TextInputModel, AddTextSelection)
 
 TEST (TextInputModel, AddTextReverseSelection)
 
 TEST (TextInputModel, AddTextSelectionWideCharacter)
 
 TEST (TextInputModel, AddTextReverseSelectionWideCharacter)
 
 TEST (TextInputModel, DeleteStart)
 
 TEST (TextInputModel, DeleteMiddle)
 
 TEST (TextInputModel, DeleteEnd)
 
 TEST (TextInputModel, DeleteWideCharacters)
 
 TEST (TextInputModel, DeleteSelection)
 
 TEST (TextInputModel, DeleteReverseSelection)
 
 TEST (TextInputModel, DeleteStartComposing)
 
 TEST (TextInputModel, DeleteStartReverseComposing)
 
 TEST (TextInputModel, DeleteMiddleComposing)
 
 TEST (TextInputModel, DeleteMiddleReverseComposing)
 
 TEST (TextInputModel, DeleteEndComposing)
 
 TEST (TextInputModel, DeleteEndReverseComposing)
 
 TEST (TextInputModel, DeleteSurroundingAtCursor)
 
 TEST (TextInputModel, DeleteSurroundingAtCursorComposing)
 
 TEST (TextInputModel, DeleteSurroundingAtCursorAll)
 
 TEST (TextInputModel, DeleteSurroundingAtCursorAllComposing)
 
 TEST (TextInputModel, DeleteSurroundingAtCursorGreedy)
 
 TEST (TextInputModel, DeleteSurroundingAtCursorGreedyComposing)
 
 TEST (TextInputModel, DeleteSurroundingBeforeCursor)
 
 TEST (TextInputModel, DeleteSurroundingBeforeCursorComposing)
 
 TEST (TextInputModel, DeleteSurroundingBeforeCursorAll)
 
 TEST (TextInputModel, DeleteSurroundingBeforeCursorAllComposing)
 
 TEST (TextInputModel, DeleteSurroundingBeforeCursorGreedy)
 
 TEST (TextInputModel, DeleteSurroundingBeforeCursorGreedyComposing)
 
 TEST (TextInputModel, DeleteSurroundingAfterCursor)
 
 TEST (TextInputModel, DeleteSurroundingAfterCursorComposing)
 
 TEST (TextInputModel, DeleteSurroundingAfterCursorAll)
 
 TEST (TextInputModel, DeleteSurroundingAfterCursorAllComposing)
 
 TEST (TextInputModel, DeleteSurroundingAfterCursorGreedy)
 
 TEST (TextInputModel, DeleteSurroundingAfterCursorGreedyComposing)
 
 TEST (TextInputModel, DeleteSurroundingSelection)
 
 TEST (TextInputModel, DeleteSurroundingReverseSelection)
 
 TEST (TextInputModel, BackspaceStart)
 
 TEST (TextInputModel, BackspaceMiddle)
 
 TEST (TextInputModel, BackspaceEnd)
 
 TEST (TextInputModel, BackspaceWideCharacters)
 
 TEST (TextInputModel, BackspaceSelection)
 
 TEST (TextInputModel, BackspaceReverseSelection)
 
 TEST (TextInputModel, BackspaceStartComposing)
 
 TEST (TextInputModel, BackspaceStartReverseComposing)
 
 TEST (TextInputModel, BackspaceMiddleComposing)
 
 TEST (TextInputModel, BackspaceMiddleReverseComposing)
 
 TEST (TextInputModel, BackspaceEndComposing)
 
 TEST (TextInputModel, BackspaceEndReverseComposing)
 
 TEST (TextInputModel, MoveCursorForwardStart)
 
 TEST (TextInputModel, MoveCursorForwardMiddle)
 
 TEST (TextInputModel, MoveCursorForwardEnd)
 
 TEST (TextInputModel, MoveCursorForwardWideCharacters)
 
 TEST (TextInputModel, MoveCursorForwardSelection)
 
 TEST (TextInputModel, MoveCursorForwardReverseSelection)
 
 TEST (TextInputModel, MoveCursorForwardStartComposing)
 
 TEST (TextInputModel, MoveCursorForwardStartReverseComposing)
 
 TEST (TextInputModel, MoveCursorForwardMiddleComposing)
 
 TEST (TextInputModel, MoveCursorForwardMiddleReverseComposing)
 
 TEST (TextInputModel, MoveCursorForwardEndComposing)
 
 TEST (TextInputModel, MoveCursorForwardEndReverseComposing)
 
 TEST (TextInputModel, MoveCursorBackStart)
 
 TEST (TextInputModel, MoveCursorBackMiddle)
 
 TEST (TextInputModel, MoveCursorBackEnd)
 
 TEST (TextInputModel, MoveCursorBackWideCharacters)
 
 TEST (TextInputModel, MoveCursorBackSelection)
 
 TEST (TextInputModel, MoveCursorBackReverseSelection)
 
 TEST (TextInputModel, MoveCursorBackStartComposing)
 
 TEST (TextInputModel, MoveCursorBackStartReverseComposing)
 
 TEST (TextInputModel, MoveCursorBackMiddleComposing)
 
 TEST (TextInputModel, MoveCursorBackMiddleReverseComposing)
 
 TEST (TextInputModel, MoveCursorBackEndComposing)
 
 TEST (TextInputModel, MoveCursorBackEndReverseComposing)
 
 TEST (TextInputModel, MoveCursorToBeginningStart)
 
 TEST (TextInputModel, SelectToBeginningStart)
 
 TEST (TextInputModel, MoveCursorToBeginningMiddle)
 
 TEST (TextInputModel, SelectToBeginningMiddle)
 
 TEST (TextInputModel, MoveCursorToBeginningEnd)
 
 TEST (TextInputModel, SelectToBeginningEnd)
 
 TEST (TextInputModel, MoveCursorToBeginningSelection)
 
 TEST (TextInputModel, SelectToBeginningSelection)
 
 TEST (TextInputModel, MoveCursorToBeginningReverseSelection)
 
 TEST (TextInputModel, SelectToBeginningReverseSelection)
 
 TEST (TextInputModel, MoveCursorToBeginningStartComposing)
 
 TEST (TextInputModel, SelectToBeginningStartComposing)
 
 TEST (TextInputModel, MoveCursorToBeginningStartReverseComposing)
 
 TEST (TextInputModel, SelectToBeginningStartReverseComposing)
 
 TEST (TextInputModel, MoveCursorToBeginningMiddleComposing)
 
 TEST (TextInputModel, SelectToBeginningMiddleComposing)
 
 TEST (TextInputModel, MoveCursorToBeginningMiddleReverseComposing)
 
 TEST (TextInputModel, SelectToBeginningMiddleReverseComposing)
 
 TEST (TextInputModel, MoveCursorToBeginningEndComposing)
 
 TEST (TextInputModel, SelectToBeginningEndComposing)
 
 TEST (TextInputModel, MoveCursorToBeginningEndReverseComposing)
 
 TEST (TextInputModel, SelectToBeginningEndReverseComposing)
 
 TEST (TextInputModel, MoveCursorToEndStart)
 
 TEST (TextInputModel, SelectToEndStart)
 
 TEST (TextInputModel, MoveCursorToEndMiddle)
 
 TEST (TextInputModel, SelectToEndMiddle)
 
 TEST (TextInputModel, MoveCursorToEndEnd)
 
 TEST (TextInputModel, SelectToEndEnd)
 
 TEST (TextInputModel, MoveCursorToEndSelection)
 
 TEST (TextInputModel, SelectToEndSelection)
 
 TEST (TextInputModel, MoveCursorToEndReverseSelection)
 
 TEST (TextInputModel, SelectToEndReverseSelection)
 
 TEST (TextInputModel, MoveCursorToEndStartComposing)
 
 TEST (TextInputModel, SelectToEndStartComposing)
 
 TEST (TextInputModel, MoveCursorToEndStartReverseComposing)
 
 TEST (TextInputModel, SelectToEndStartReverseComposing)
 
 TEST (TextInputModel, MoveCursorToEndMiddleComposing)
 
 TEST (TextInputModel, SelectToEndMiddleComposing)
 
 TEST (TextInputModel, MoveCursorToEndMiddleReverseComposing)
 
 TEST (TextInputModel, SelectToEndMiddleReverseComposing)
 
 TEST (TextInputModel, MoveCursorToEndEndComposing)
 
 TEST (TextInputModel, SelectToEndEndComposing)
 
 TEST (TextInputModel, MoveCursorToEndEndReverseComposing)
 
 TEST (TextInputModel, SelectToEndEndReverseComposing)
 
 TEST (TextInputModel, GetCursorOffset)
 
 TEST (TextInputModel, GetCursorOffsetSelection)
 
 TEST (TextInputModel, GetCursorOffsetReverseSelection)
 
 TEST (TextRange, TextRangeFromPositionZero)
 
 TEST (TextRange, TextRangeFromPositionNonZero)
 
 TEST (TextRange, TextRangeFromRange)
 
 TEST (TextRange, TextRangeFromReversedRange)
 
 TEST (TextRange, SetBase)
 
 TEST (TextRange, SetBaseReversed)
 
 TEST (TextRange, SetExtent)
 
 TEST (TextRange, SetExtentReversed)
 
 TEST (TextRange, SetStart)
 
 TEST (TextRange, SetStartReversed)
 
 TEST (TextRange, SetEnd)
 
 TEST (TextRange, SetEndReversed)
 
 TEST (TextRange, ContainsPreStartPosition)
 
 TEST (TextRange, ContainsStartPosition)
 
 TEST (TextRange, ContainsMiddlePosition)
 
 TEST (TextRange, ContainsEndPosition)
 
 TEST (TextRange, ContainsPostEndPosition)
 
 TEST (TextRange, ContainsPreStartPositionReversed)
 
 TEST (TextRange, ContainsStartPositionReversed)
 
 TEST (TextRange, ContainsMiddlePositionReversed)
 
 TEST (TextRange, ContainsEndPositionReversed)
 
 TEST (TextRange, ContainsPostEndPositionReversed)
 
 TEST (TextRange, ContainsRangePreStartPosition)
 
 TEST (TextRange, ContainsRangeSpanningStartPosition)
 
 TEST (TextRange, ContainsRangeStartPosition)
 
 TEST (TextRange, ContainsRangeMiddlePosition)
 
 TEST (TextRange, ContainsRangeEndPosition)
 
 TEST (TextRange, ContainsRangeSpanningEndPosition)
 
 TEST (TextRange, ContainsRangePostEndPosition)
 
 TEST (TextRange, ContainsRangePreStartPositionReversed)
 
 TEST (TextRange, ContainsRangeSpanningStartPositionReversed)
 
 TEST (TextRange, ContainsRangeStartPositionReversed)
 
 TEST (TextRange, ContainsRangeMiddlePositionReversed)
 
 TEST (TextRange, ContainsRangeSpanningEndPositionReversed)
 
 TEST (TextRange, ContainsRangeEndPositionReversed)
 
 TEST (TextRange, ContainsRangePostEndPositionReversed)
 
 TEST (TextRange, ReversedForwardRange)
 
 TEST (TextRange, ReversedCollapsedRange)
 
 TEST (TextRange, ReversedReversedRange)
 
fml::MallocMapping CopyNSDataToMapping (NSData *data)
 
NSData * ConvertMappingToNSData (fml::MallocMapping buffer)
 
std::unique_ptr< fml::MappingConvertNSDataToMappingPtr (NSData *data)
 
NSData * CopyMappingPtrToNSData (std::unique_ptr< fml::Mapping > mapping)
 
fml::CommandLine CommandLineFromNSProcessInfo ()
 
FlutterStandardField FlutterStandardFieldForDataType (FlutterStandardDataType type)
 
FlutterStandardDataType FlutterStandardDataTypeForField (FlutterStandardField field)
 
UInt8 elementSizeForFlutterStandardDataType (FlutterStandardDataType type)
 
static void ReplaceSemanticsObject (SemanticsObject *oldObject, SemanticsObject *newObject, NSMutableDictionary< NSNumber *, SemanticsObject *> *objects)
 
static SemanticsObjectCreateObject (const flutter::SemanticsNode &node, fml::WeakPtr< AccessibilityBridge > weak_ptr)
 
static bool DidFlagChange (const flutter::SemanticsNode &oldNode, const flutter::SemanticsNode &newNode, SemanticsFlags flag)
 
CATransform3D GetCATransform3DFromSkMatrix (const SkMatrix &matrix)
 
void ResetAnchor (CALayer *layer)
 
bool IsIosEmbeddedViewsPreviewEnabled ()
 
static IOSContextGLCastToGLContext (const std::shared_ptr< IOSContext > &context)
 
static IOSContextMetalCastToMetalContext (const std::shared_ptr< IOSContext > &context)
 
IOSRenderingAPI GetRenderingAPIForProcess (bool force_software)
 
Class GetCoreAnimationLayerClassForRenderingAPI (IOSRenderingAPI rendering_api)
 
static bool ValidNumTextures (int expected, int actual)
 
static SkISize TransformedSurfaceSize (const SkISize &size, const SkMatrix &transformation)
 
static FlutterBackingStoreConfig MakeBackingStoreConfig (const SkISize &backing_store_size)
 
static std::unique_ptr< FlutterPlatformViewMutationConvertMutation (double opacity)
 
static std::unique_ptr< FlutterPlatformViewMutationConvertMutation (const SkRect &rect)
 
static FlutterSize VectorToSize (const SkVector &vector)
 
static std::unique_ptr< FlutterPlatformViewMutationConvertMutation (const SkRRect &rrect)
 
static std::unique_ptr< FlutterPlatformViewMutationConvertMutation (const SkMatrix &matrix)
 
static std::pair< bool, fml::RefPtr< EmbedderTaskRunner > > CreateEmbedderTaskRunner (const FlutterTaskRunnerDescription *description)
 Attempts to create a task runner from an embedder task runner description. The first boolean in the pair indicate whether the embedder specified an invalid task runner description. In this case, engine launch must be aborted. If the embedder did not specify any task runner, an engine managed task runner and thread must be selected instead. More...
 
static fml::RefPtr< fml::TaskRunnerGetCurrentThreadTaskRunner ()
 
 TEST (FlutterEngineTest, CreateDestroy)
 
 TEST (FlutterEngineTest, ExplicitShutDown)
 
 TEST (FlutterEngineTest, RunloopTimeoutTranslation)
 
 TEST (FlutterViewControllerTest, CreateDestroy)
 
 TEST (FlutterWindowTest, SetSizeLimits)
 
 TEST (PluginRegistrarGlfwTest, GetView)
 
 TEST (PluginRegistrarGlfwTest, PluginDestroyedBeforeRegistrar)
 
std::vector< LanguageInfoGetPreferredLanguageInfo ()
 
std::vector< FlutterLocaleConvertToFlutterLocale (const std::vector< LanguageInfo > &languages)
 
 TEST_F (DartProjectTest, StandardProjectFormat)
 
 TEST_F (DartProjectTest, ProjectWithCustomPaths)
 
 TEST_F (DartProjectTest, DartEntrypointArguments)
 
 TEST (FlutterEngineTest, ProcessMessages)
 
 TEST (FlutterEngineTest, ReloadFonts)
 
 TEST (FlutterEngineTest, ReloadBrightness)
 
 TEST (FlutterEngineTest, GetMessenger)
 
 TEST (FlutterEngineTest, DartEntrypointArgs)
 
 TEST (FlutterViewControllerTest, GetEngine)
 
 TEST (FlutterViewControllerTest, GetView)
 
 TEST (FlutterViewTest, HwndAccessPassesThrough)
 
 TEST (PluginRegistrarWindowsTest, GetView)
 
 TEST (PluginRegistrarWindowsTest, PluginDestroyedBeforeRegistrar)
 
 TEST (PluginRegistrarWindowsTest, RegisterUnregister)
 
 TEST (PluginRegistrarWindowsTest, CallsRegisteredDelegates)
 
 TEST (PluginRegistrarWindowsTest, StopsOnceHandled)
 
UINT GetDpiForHWND (HWND hwnd)
 
UINT GetDpiForMonitor (HMONITOR monitor)
 
static uint64_t ConvertWinButtonToFlutterButton (UINT button)
 
static bool SurfaceWillUpdate (size_t cur_width, size_t cur_height, size_t target_width, size_t target_height)
 
static bool IsValid (double value)
 
std::string ConvertChar32ToUtf8 (char32_t ch)
 
static bool isEasciiPrintable (int codeUnit)
 
static uint64_t toLower (uint64_t n)
 
static uint16_t normalizeScancode (int windowsScanCode, bool extended)
 
bool isWindowInForeground ()
 
std::string Utf8FromUtf16 (const std::wstring_view utf16_string)
 
std::wstring Utf16FromUtf8 (const std::string_view utf8_string)
 
std::vector< std::wstring > GetPreferredLanguages ()
 
LanguageInfo ParseLanguageName (std::wstring language_name)
 
std::wstring GetUserTimeFormat ()
 
bool Prefer24HourTime (std::wstring time_format)
 
std::wstring GetPreferredBrightness ()
 
static uint16_t ResolveKeyCode (uint16_t original, bool extended, uint8_t scancode)
 
static bool IsPrintable (uint32_t c)
 
 TEST (SamplingProfilerTest, DeleteAfterStart)
 
static void UnblockSIGPROF ()
 
int RunTester (const flutter::Settings &settings, bool run_forever, bool multithreaded)
 
const char * GetFlutterEngineVersion ()
 
const char * GetSkiaVersion ()
 
const char * GetDartVersion ()
 

Variables

constexpr double kMegaByteSizeInBytes = (1 << 20)
 
constexpr float invert_color_matrix [20]
 
static std::string gGoldenDir
 
static std::string gFontFile
 
static const size_t kMaxSamples = 120
 
static const size_t kMaxFrameMarkers = 8
 
static constexpr SkRect kGiantRect = SkRect::MakeLTRB(-1E9F, -1E9F, 1E9F, 1E9F)
 
const int kDisplayRasterizerStatistics = 1 << 0
 
const int kVisualizeRasterizerStatistics = 1 << 1
 
const int kDisplayEngineStatistics = 1 << 2
 
const int kVisualizeEngineStatistics = 1 << 3
 
const SkScalar kLightHeight = 600
 
const SkScalar kLightRadius = 800
 
static const tonic::DartWrapperInfo kDartWrapperInfo_ui_FragmentShader
 
static const tonic::DartWrapperInfo kDartWrapperInfo_ui_Image
 
static const std::array< SkSamplingOptions, 4 > filter_qualities
 
static const int kSkMatrixIndexToMatrix4Index []
 
constexpr int kIsAntiAliasIndex = 0
 
constexpr int kColorIndex = 1
 
constexpr int kBlendModeIndex = 2
 
constexpr int kStyleIndex = 3
 
constexpr int kStrokeWidthIndex = 4
 
constexpr int kStrokeCapIndex = 5
 
constexpr int kStrokeJoinIndex = 6
 
constexpr int kStrokeMiterLimitIndex = 7
 
constexpr int kFilterQualityIndex = 8
 
constexpr int kMaskFilterIndex = 9
 
constexpr int kMaskFilterBlurStyleIndex = 10
 
constexpr int kMaskFilterSigmaIndex = 11
 
constexpr int kInvertColorIndex = 12
 
constexpr int kDitherIndex = 13
 
constexpr size_t kDataByteCount = 56
 
constexpr int kShaderIndex = 0
 
constexpr int kColorFilterIndex = 1
 
constexpr int kImageFilterIndex = 2
 
constexpr int kObjectCount = 3
 
constexpr uint32_t kColorDefault = 0xFF000000
 
constexpr uint32_t kBlendModeDefault
 
constexpr double kStrokeMiterLimitDefault = 4.0
 
constexpr float invert_colors [20]
 
static const char * kHandleKey = "handle"
 
static const char * kRepresentationKey = "representation"
 
static const char * kNameKey = "name"
 
static const char * kClassNameKey = "class_name"
 
static const char * kLibraryPathKey = "library_path"
 
static const char * kCacheName = "flutter_callback_cache.json"
 
constexpr int32_t kMinPlatformViewId = -1
 
const int kVerticalScrollSemanticsActions
 
const int kHorizontalScrollSemanticsActions
 
const int kScrollableSemanticsActions
 
const int kScrollableSemanticsFlags
 
static constexpr int kKeyDataFieldCount = 5
 
static constexpr int kBytesPerKeyField = sizeof(int64_t)
 
static constexpr int kPointerDataFieldCount = 29
 
static constexpr int kBytesPerField = sizeof(int64_t)
 
static const char * kDartLanguageArgs []
 
static const char * kDartPrecompilationArgs []
 
static FML_ALLOW_UNUSED_TYPE const char * kDartWriteProtectCodeArgs []
 
static FML_ALLOW_UNUSED_TYPE const char * kDartDisableIntegerDivisionArgs []
 
static const char * kDartAssertArgs []
 
static const char * kDartStartPausedArgs []
 
static const char * kDartDisableServiceAuthCodesArgs []
 
static const char * kDartEndlessTraceBufferArgs []
 
static const char * kDartSystraceTraceBufferArgs []
 
static FML_ALLOW_UNUSED_TYPE const char * kDartDefaultTraceStreamsArgs []
 
static const char * kDartStartupTraceStreamsArgs []
 
static const char * kDartSystraceTraceStreamsArgs []
 
constexpr char kFileUriPrefix [] = "file://"
 
constexpr size_t kFileUriPrefixLength = sizeof(kFileUriPrefix) - 1
 
static const char kStdoutStreamId [] = "Stdout"
 
static const char kStderrStreamId [] = "Stderr"
 
static std::atomic_size_t gVMLaunchCount
 
static std::mutex gVMMutex
 
static std::weak_ptr< DartVMgVM
 
static std::shared_ptr< DartVM > * gVMLeak
 
static std::mutex gVMDependentsMutex
 
static std::weak_ptr< const DartVMDatagVMData
 
static std::weak_ptr< ServiceProtocolgVMServiceProtocol
 
static std::weak_ptr< IsolateNameServergVMIsolateNameServer
 
static constexpr std::string_view kViewIdPrefx = "_flutterView/"
 
static constexpr std::string_view kListViewsExtensionName
 
static constexpr double kUnknownDisplayRefreshRate = 0
 To be used when the display refresh rate is unknown. More...
 
static constexpr char kAssetChannel [] = "flutter/assets"
 
static constexpr char kLifecycleChannel [] = "flutter/lifecycle"
 
static constexpr char kNavigationChannel [] = "flutter/navigation"
 
static constexpr char kLocalizationChannel [] = "flutter/localization"
 
static constexpr char kSettingsChannel [] = "flutter/settings"
 
static constexpr char kIsolateChannel [] = "flutter/isolate"
 
constexpr char kSkiaChannel [] = "flutter/skia"
 
constexpr char kSystemChannel [] = "flutter/system"
 
constexpr char kTypeKey [] = "type"
 
constexpr char kFontChange [] = "fontsChange"
 
enum flutter::DartErrorCode __attribute__
 
DEF_SWITCHES_START aot vmservice shared library name
 
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot data
 
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
 
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 h
 
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 observatory host
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not set
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable observatory
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode ipv6
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace buffer
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For example
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however skia deterministic rendering
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however skia deterministic Skips the call to thus avoiding swapping out some Skia function pointers based on available CPU features This is used to obtain deterministic behavior in Skia rendering disable service auth codes
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however skia deterministic Skips the call to thus avoiding swapping out some Skia function pointers based on available CPU features This is used to obtain deterministic behavior in Skia rendering disable service auth Disable the requirement for authentication codes for communicating with the VM service start paused
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however skia deterministic Skips the call to thus avoiding swapping out some Skia function pointers based on available CPU features This is used to obtain deterministic behavior in Skia rendering disable service auth Disable the requirement for authentication codes for communicating with the VM service start Start the application paused in the Dart debugger trace skia
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however skia deterministic Skips the call to thus avoiding swapping out some Skia function pointers based on available CPU features This is used to obtain deterministic behavior in Skia rendering disable service auth Disable the requirement for authentication codes for communicating with the VM service start Start the application paused in the Dart debugger trace Trace Skia calls This is useful when debugging the GPU threed By default
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however skia deterministic Skips the call to thus avoiding swapping out some Skia function pointers based on available CPU features This is used to obtain deterministic behavior in Skia rendering disable service auth Disable the requirement for authentication codes for communicating with the VM service start Start the application paused in the Dart debugger trace Trace Skia calls This is useful when debugging the GPU threed By Skia tracing is not enabled to reduce the number of traced events trace allowlist
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however skia deterministic Skips the call to thus avoiding swapping out some Skia function pointers based on available CPU features This is used to obtain deterministic behavior in Skia rendering disable service auth Disable the requirement for authentication codes for communicating with the VM service start Start the application paused in the Dart debugger trace Trace Skia calls This is useful when debugging the GPU threed By Skia tracing is not enabled to reduce the number of traced events trace Filters out all trace events except those that are specified in this comma separated list of allowed prefixes cache sksl
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however skia deterministic Skips the call to thus avoiding swapping out some Skia function pointers based on available CPU features This is used to obtain deterministic behavior in Skia rendering disable service auth Disable the requirement for authentication codes for communicating with the VM service start Start the application paused in the Dart debugger trace Trace Skia calls This is useful when debugging the GPU threed By Skia tracing is not enabled to reduce the number of traced events trace Filters out all trace events except those that are specified in this comma separated list of allowed prefixes cache Only cache the shader in SkSL instead of binary or GLSL This should only be used during development phases The generated SkSLs can later be used in the release build for shader precompilation at launch in order to eliminate the shader compile jank trace systrace
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however skia deterministic Skips the call to thus avoiding swapping out some Skia function pointers based on available CPU features This is used to obtain deterministic behavior in Skia rendering disable service auth Disable the requirement for authentication codes for communicating with the VM service start Start the application paused in the Dart debugger trace Trace Skia calls This is useful when debugging the GPU threed By Skia tracing is not enabled to reduce the number of traced events trace Filters out all trace events except those that are specified in this comma separated list of allowed prefixes cache Only cache the shader in SkSL instead of binary or GLSL This should only be used during development phases The generated SkSLs can later be used in the release build for shader precompilation at launch in order to eliminate the shader compile jank trace Trace to the system use test fonts
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however skia deterministic Skips the call to thus avoiding swapping out some Skia function pointers based on available CPU features This is used to obtain deterministic behavior in Skia rendering disable service auth Disable the requirement for authentication codes for communicating with the VM service start Start the application paused in the Dart debugger trace Trace Skia calls This is useful when debugging the GPU threed By Skia tracing is not enabled to reduce the number of traced events trace Filters out all trace events except those that are specified in this comma separated list of allowed prefixes cache Only cache the shader in SkSL instead of binary or GLSL This should only be used during development phases The generated SkSLs can later be used in the release build for shader precompilation at launch in order to eliminate the shader compile jank trace Trace to the system use test Running tests that layout and measure text will not yield consistent results across various platforms Enabling this option will make font resolution default to the Ahem test font on all prefetched default font manager
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however skia deterministic Skips the call to thus avoiding swapping out some Skia function pointers based on available CPU features This is used to obtain deterministic behavior in Skia rendering disable service auth Disable the requirement for authentication codes for communicating with the VM service start Start the application paused in the Dart debugger trace Trace Skia calls This is useful when debugging the GPU threed By Skia tracing is not enabled to reduce the number of traced events trace Filters out all trace events except those that are specified in this comma separated list of allowed prefixes cache Only cache the shader in SkSL instead of binary or GLSL This should only be used during development phases The generated SkSLs can later be used in the release build for shader precompilation at launch in order to eliminate the shader compile jank trace Trace to the system use test Running tests that layout and measure text will not yield consistent results across various platforms Enabling this option will make font resolution default to the Ahem test font on all prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run forever
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however skia deterministic Skips the call to thus avoiding swapping out some Skia function pointers based on available CPU features This is used to obtain deterministic behavior in Skia rendering disable service auth Disable the requirement for authentication codes for communicating with the VM service start Start the application paused in the Dart debugger trace Trace Skia calls This is useful when debugging the GPU threed By Skia tracing is not enabled to reduce the number of traced events trace Filters out all trace events except those that are specified in this comma separated list of allowed prefixes cache Only cache the shader in SkSL instead of binary or GLSL This should only be used during development phases The generated SkSLs can later be used in the release build for shader precompilation at launch in order to eliminate the shader compile jank trace Trace to the system use test Running tests that layout and measure text will not yield consistent results across various platforms Enabling this option will make font resolution default to the Ahem test font on all prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive mode
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however skia deterministic Skips the call to thus avoiding swapping out some Skia function pointers based on available CPU features This is used to obtain deterministic behavior in Skia rendering disable service auth Disable the requirement for authentication codes for communicating with the VM service start Start the application paused in the Dart debugger trace Trace Skia calls This is useful when debugging the GPU threed By Skia tracing is not enabled to reduce the number of traced events trace Filters out all trace events except those that are specified in this comma separated list of allowed prefixes cache Only cache the shader in SkSL instead of binary or GLSL This should only be used during development phases The generated SkSLs can later be used in the release build for shader precompilation at launch in order to eliminate the shader compile jank trace Trace to the system use test Running tests that layout and measure text will not yield consistent results across various platforms Enabling this option will make font resolution default to the Ahem test font on all prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive keep the shell running after the Dart script has completed disallow insecure connections
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however skia deterministic Skips the call to thus avoiding swapping out some Skia function pointers based on available CPU features This is used to obtain deterministic behavior in Skia rendering disable service auth Disable the requirement for authentication codes for communicating with the VM service start Start the application paused in the Dart debugger trace Trace Skia calls This is useful when debugging the GPU threed By Skia tracing is not enabled to reduce the number of traced events trace Filters out all trace events except those that are specified in this comma separated list of allowed prefixes cache Only cache the shader in SkSL instead of binary or GLSL This should only be used during development phases The generated SkSLs can later be used in the release build for shader precompilation at launch in order to eliminate the shader compile jank trace Trace to the system use test Running tests that layout and measure text will not yield consistent results across various platforms Enabling this option will make font resolution default to the Ahem test font on all prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive keep the shell running after the Dart script has completed disallow insecure By dart
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however skia deterministic Skips the call to thus avoiding swapping out some Skia function pointers based on available CPU features This is used to obtain deterministic behavior in Skia rendering disable service auth Disable the requirement for authentication codes for communicating with the VM service start Start the application paused in the Dart debugger trace Trace Skia calls This is useful when debugging the GPU threed By Skia tracing is not enabled to reduce the number of traced events trace Filters out all trace events except those that are specified in this comma separated list of allowed prefixes cache Only cache the shader in SkSL instead of binary or GLSL This should only be used during development phases The generated SkSLs can later be used in the release build for shader precompilation at launch in order to eliminate the shader compile jank trace Trace to the system use test Running tests that layout and measure text will not yield consistent results across various platforms Enabling this option will make font resolution default to the Ahem test font on all prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive keep the shell running after the Dart script has completed disallow insecure By all insecure connections are rejected force multithreading
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however skia deterministic Skips the call to thus avoiding swapping out some Skia function pointers based on available CPU features This is used to obtain deterministic behavior in Skia rendering disable service auth Disable the requirement for authentication codes for communicating with the VM service start Start the application paused in the Dart debugger trace Trace Skia calls This is useful when debugging the GPU threed By Skia tracing is not enabled to reduce the number of traced events trace Filters out all trace events except those that are specified in this comma separated list of allowed prefixes cache Only cache the shader in SkSL instead of binary or GLSL This should only be used during development phases The generated SkSLs can later be used in the release build for shader precompilation at launch in order to eliminate the shader compile jank trace Trace to the system use test Running tests that layout and measure text will not yield consistent results across various platforms Enabling this option will make font resolution default to the Ahem test font on all prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive keep the shell running after the Dart script has completed disallow insecure By all insecure connections are rejected force Uses separate threads for the platform
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however skia deterministic Skips the call to thus avoiding swapping out some Skia function pointers based on available CPU features This is used to obtain deterministic behavior in Skia rendering disable service auth Disable the requirement for authentication codes for communicating with the VM service start Start the application paused in the Dart debugger trace Trace Skia calls This is useful when debugging the GPU threed By Skia tracing is not enabled to reduce the number of traced events trace Filters out all trace events except those that are specified in this comma separated list of allowed prefixes cache Only cache the shader in SkSL instead of binary or GLSL This should only be used during development phases The generated SkSLs can later be used in the release build for shader precompilation at launch in order to eliminate the shader compile jank trace Trace to the system use test Running tests that layout and measure text will not yield consistent results across various platforms Enabling this option will make font resolution default to the Ahem test font on all prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive keep the shell running after the Dart script has completed disallow insecure By all insecure connections are rejected force Uses separate threads for the UI
 
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however skia deterministic Skips the call to thus avoiding swapping out some Skia function pointers based on available CPU features This is used to obtain deterministic behavior in Skia rendering disable service auth Disable the requirement for authentication codes for communicating with the VM service start Start the application paused in the Dart debugger trace Trace Skia calls This is useful when debugging the GPU threed By Skia tracing is not enabled to reduce the number of traced events trace Filters out all trace events except those that are specified in this comma separated list of allowed prefixes cache Only cache the shader in SkSL instead of binary or GLSL This should only be used during development phases The generated SkSLs can later be used in the release build for shader precompilation at launch in order to eliminate the shader compile jank trace Trace to the system use test Running tests that layout and measure text will not yield consistent results across various platforms Enabling this option will make font resolution default to the Ahem test font on all prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive keep the shell running after the Dart script has completed disallow insecure By all insecure connections are rejected force Uses separate threads for the GPU and IO task runners By a single thread is used for all task runners Only available in the flutter_tester enable skparagraph
 
static constexpr const char * kVsyncFlowName = "VsyncFlow"
 
static constexpr const char * kVsyncTraceName = "VsyncProcessCallback"
 
static const int kGrCacheMaxCount = 8192
 
static const size_t kGrCacheMaxByteSize = 24 * (1 << 20)
 
static fml::jni::ScopedJavaGlobalRef< jclass > * g_flutter_jni_class = nullptr
 
static jmethodID g_decode_image_method = nullptr
 
const uint8_t kPlatformStrongDill []
 
const intptr_t kPlatformStrongDillSize
 
static std::unique_ptr< FlutterMaing_flutter_main
 
static fml::jni::ScopedJavaGlobalRef< jclass > * g_flutter_callback_info_class
 
static fml::jni::ScopedJavaGlobalRef< jclass > * g_flutter_jni_class = nullptr
 
static fml::jni::ScopedJavaGlobalRef< jclass > * g_java_weak_reference_class
 
static fml::jni::ScopedJavaGlobalRef< jclass > * g_texture_wrapper_class = nullptr
 
static fml::jni::ScopedJavaGlobalRef< jclass > * g_java_long_class = nullptr
 
static jmethodID g_flutter_callback_info_constructor = nullptr
 
static jfieldID g_jni_shell_holder_field = nullptr
 
static jmethodID g_jni_constructor = nullptr
 
static jmethodID g_long_constructor = nullptr
 
static jmethodID g_handle_platform_message_method = nullptr
 
static jmethodID g_handle_platform_message_response_method = nullptr
 
static jmethodID g_update_semantics_method = nullptr
 
static jmethodID g_update_custom_accessibility_actions_method = nullptr
 
static jmethodID g_on_first_frame_method = nullptr
 
static jmethodID g_on_engine_restart_method = nullptr
 
static jmethodID g_create_overlay_surface_method = nullptr
 
static jmethodID g_destroy_overlay_surfaces_method = nullptr
 
static jmethodID g_on_begin_frame_method = nullptr
 
static jmethodID g_on_end_frame_method = nullptr
 
static jmethodID g_java_weak_reference_get_method = nullptr
 
static jmethodID g_attach_to_gl_context_method = nullptr
 
static jmethodID g_update_tex_image_method = nullptr
 
static jmethodID g_get_transform_matrix_method = nullptr
 
static jmethodID g_detach_from_gl_context_method = nullptr
 
static jmethodID g_compute_platform_resolved_locale_method = nullptr
 
static jmethodID g_request_dart_deferred_library_method = nullptr
 
static jmethodID g_on_display_platform_view_method = nullptr
 
static jmethodID g_on_display_overlay_surface_method = nullptr
 
static jmethodID g_overlay_surface_id_method = nullptr
 
static jmethodID g_overlay_surface_surface_method = nullptr
 
static fml::jni::ScopedJavaGlobalRef< jclass > * g_mutators_stack_class = nullptr
 
static jmethodID g_mutators_stack_init_method = nullptr
 
static jmethodID g_mutators_stack_push_transform_method = nullptr
 
static jmethodID g_mutators_stack_push_cliprect_method = nullptr
 
static jmethodID g_mutators_stack_push_cliprrect_method = nullptr
 
static fml::jni::ScopedJavaGlobalRef< jclass > * g_vsync_waiter_class = nullptr
 
static jmethodID g_async_wait_for_vsync_method_ = nullptr
 
constexpr int kHasScrollingAction
 
const char *const kOrientationUpdateNotificationName
 
const char *const kOrientationUpdateNotificationKey
 
const char *const kOverlayStyleUpdateNotificationName
 
const char *const kOverlayStyleUpdateNotificationKey
 
static NSString *const AccessibilityLoadCompleteNotification = @"@"AXLoadComplete"
 
static NSString *const AccessibilityInvalidStatusChangedNotification = @"@"AXInvalidStatusChanged"
 
static NSString *const AccessibilityLiveRegionCreatedNotification = @"@"AXLiveRegionCreated"
 
static NSString *const AccessibilityLiveRegionChangedNotification = @"@"AXLiveRegionChanged"
 
static NSString *const AccessibilityExpandedChanged = @"@"AXExpandedChanged"
 
static NSString *const AccessibilityMenuItemSelectedNotification = @"@"AXMenuItemSelected"
 
constexpr const char * kFlutterThreadName = "io.flutter"
 
static constexpr double kControllerScrollMultiplier = 3
 
static constexpr uint32_t kMinPointerId = 0
 
static constexpr uint32_t kMaxPointerId = 128
 
constexpr uint32_t kWindowFrameBufferID = 0
 
static constexpr int32_t kDefaultPointerDeviceId = 0
 

Detailed Description

Note
Deprecated MOCK_METHOD macros used until this issue is resolved:

Typedef Documentation

◆ AccessibilityNodeId

◆ BinaryMessageHandler

typedef std::function< void(const uint8_t* message, size_t message_size, BinaryReply reply)> flutter::BinaryMessageHandler

Definition at line 24 of file binary_messenger.h.

◆ BinaryReply

typedef std::function<void(const uint8_t* reply, size_t reply_size)> flutter::BinaryReply

Definition at line 17 of file binary_messenger.h.

◆ ChildIsolatePreparer

Definition at line 20 of file dart_isolate_group_data.h.

◆ CurrentTimeProc

typedef uint64_t(* flutter::CurrentTimeProc) ()

Definition at line 20 of file task_runner.h.

◆ CustomAccessibilityActionUpdates

using flutter::CustomAccessibilityActionUpdates = typedef std::unordered_map<int32_t, CustomAccessibilityAction>

Definition at line 32 of file custom_accessibility_action.h.

◆ DisplayId

typedef uint64_t flutter::DisplayId

Unique ID per display that is stable until the Flutter application restarts. See also: flutter::Display

Definition at line 16 of file display.h.

◆ DisplayListRasterCacheKey

Definition at line 56 of file raster_cache_key.h.

◆ EGLResult

template<class T >
using flutter::EGLResult = typedef std::pair<bool, T>

Definition at line 17 of file android_context_gl.cc.

◆ EncodableList

using flutter::EncodableList = typedef std::vector<EncodableValue>

Definition at line 94 of file encodable_value.h.

◆ EncodableMap

Definition at line 95 of file encodable_value.h.

◆ ExternalTextureGLState

◆ FrameRasterizedCallback

Definition at line 88 of file settings.h.

◆ GamepadAddedRemovedCallback

Definition at line 22 of file game_pad_winuwp.h.

◆ GamepadButtonCallback

using flutter::GamepadButtonCallback = typedef std::function<void(winrt::Windows::Gaming::Input::GamepadButtons)>

Definition at line 21 of file game_pad_winuwp.h.

◆ GamepadDualAxisCallback

using flutter::GamepadDualAxisCallback = typedef std::function<void(double, double)>

Definition at line 19 of file game_pad_winuwp.h.

◆ GamepadSingleAxisCallback

using flutter::GamepadSingleAxisCallback = typedef std::function<void(double)>

Definition at line 18 of file game_pad_winuwp.h.

◆ glBindTextureProc

typedef void(* flutter::glBindTextureProc) (GLenum target, GLuint texture)

Definition at line 24 of file external_texture_gl.h.

◆ glDeleteTexturesProc

typedef void(* flutter::glDeleteTexturesProc) (GLsizei n, const GLuint *textures)

Definition at line 23 of file external_texture_gl.h.

◆ glGenTexturesProc

typedef void(* flutter::glGenTexturesProc) (GLsizei n, GLuint *textures)

Definition at line 22 of file external_texture_gl.h.

◆ glTexImage2DProc

typedef void(* flutter::glTexImage2DProc) (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *data)

Definition at line 26 of file external_texture_gl.h.

◆ glTexParameteriProc

typedef void(* flutter::glTexParameteriProc) (GLenum target, GLenum pname, GLint param)

Definition at line 25 of file external_texture_gl.h.

◆ GPUCAMetalLayerHandle

Definition at line 24 of file gpu_surface_metal_delegate.h.

◆ GPUMTLCommandQueueHandle

Definition at line 21 of file gpu_surface_metal_delegate.h.

◆ GPUMTLDeviceHandle

Definition at line 18 of file gpu_surface_metal_delegate.h.

◆ GPUMTLTextureHandle

typedef const void* flutter::GPUMTLTextureHandle

Definition at line 27 of file gpu_surface_metal_delegate.h.

◆ Gradient

Definition at line 15 of file gradient.cc.

◆ Image

Definition at line 15 of file image.cc.

◆ ImageGeneratorFactory

using flutter::ImageGeneratorFactory = typedef std::function<std::shared_ptr<ImageGenerator>(sk_sp<SkData> buffer)>

ImageGeneratorFactory is the top level primitive for specifying an image decoder in Flutter. When called, it should return an ImageGenerator that typically compatible with the given input data.

Definition at line 22 of file image_generator_registry.h.

◆ JavaLocalRef

using flutter::JavaLocalRef = typedef std::nullptr_t

Definition at line 25 of file platform_view_android_jni.h.

◆ LayerRasterCacheKey

using flutter::LayerRasterCacheKey = typedef RasterCacheKey<uint64_t>

Definition at line 61 of file raster_cache_key.h.

◆ LogMessageCallback

using flutter::LogMessageCallback = typedef std::function<void(const std::string& , const std::string& )>

Definition at line 80 of file settings.h.

◆ MappingCallback

using flutter::MappingCallback = typedef std::function<std::unique_ptr<fml::Mapping>(void)>

Definition at line 84 of file settings.h.

◆ Mappings

using flutter::Mappings = typedef std::vector<std::unique_ptr<const fml::Mapping> >

Definition at line 85 of file settings.h.

◆ MappingsCallback

Definition at line 86 of file settings.h.

◆ MessageHandler

template<typename T >
using flutter::MessageHandler = typedef std::function<void(const T& message, const MessageReply<T>& reply)>

Definition at line 30 of file basic_message_channel.h.

◆ MessageReply

template<typename T >
using flutter::MessageReply = typedef std::function<void(const T& reply)>

Definition at line 22 of file basic_message_channel.h.

◆ MethodCallHandler

template<typename T >
using flutter::MethodCallHandler = typedef std::function<void(const MethodCall<T>& call, std::unique_ptr<MethodResult<T> > result)>

Definition at line 28 of file method_channel.h.

◆ PaintRegionMap

using flutter::PaintRegionMap = typedef std::map<uint64_t, PaintRegion>

Definition at line 40 of file diff_context.h.

◆ Path

Definition at line 20 of file path.cc.

◆ PathMeasure

Definition at line 20 of file path_measure.cc.

◆ PictureRasterCacheKey

Definition at line 53 of file raster_cache_key.h.

◆ PlatformWindow

using flutter::PlatformWindow = typedef HWND

Definition at line 37 of file window_binding_handler.h.

◆ PointerDataDispatcherMaker

Signature for constructing PointerDataDispatcher.

Parameters
[in]delegatethe Flutter::Engine

Definition at line 173 of file pointer_data_dispatcher.h.

◆ ResultHandlerError

template<typename T >
using flutter::ResultHandlerError = typedef std::function<void(const std::string& error_code, const std::string& error_message, const T* error_details)>

Definition at line 23 of file method_result_functions.h.

◆ ResultHandlerNotImplemented

template<typename T >
using flutter::ResultHandlerNotImplemented = typedef std::function<void()>

Definition at line 25 of file method_result_functions.h.

◆ ResultHandlerSuccess

template<typename T >
using flutter::ResultHandlerSuccess = typedef std::function<void(const T* result)>

Definition at line 19 of file method_result_functions.h.

◆ Sampler

Sampler is run during SamplingProfiler::SampleRepeatedly. Each platform should implement its version of a Sampler if they decide to participate in gathering profiling metrics.

See also
flutter::SamplingProfiler::SampleRepeatedly

Definition at line 73 of file sampling_profiler.h.

◆ SemanticsNodeUpdates

using flutter::SemanticsNodeUpdates = typedef std::unordered_map<int32_t, SemanticsNode>

Definition at line 148 of file semantics_node.h.

◆ StreamHandlerCancel

template<typename T >
using flutter::StreamHandlerCancel = typedef std::function<std::unique_ptr<StreamHandlerError<T> >(const T* arguments)>

Definition at line 27 of file event_stream_handler_functions.h.

◆ StreamHandlerListen

template<typename T >
using flutter::StreamHandlerListen = typedef std::function<std::unique_ptr<StreamHandlerError<T> >( const T* arguments, std::unique_ptr<EventSink<T> >&& events)>

Definition at line 23 of file event_stream_handler_functions.h.

◆ StringAttributePtr

using flutter::StringAttributePtr = typedef std::shared_ptr<flutter::StringAttribute>

Definition at line 15 of file string_attribute.h.

◆ StringAttributes

using flutter::StringAttributes = typedef std::vector<StringAttributePtr>

Definition at line 16 of file string_attribute.h.

◆ TaskObserverAdd

using flutter::TaskObserverAdd = typedef std::function<void(intptr_t , fml::closure )>

Definition at line 73 of file settings.h.

◆ TaskObserverRemove

using flutter::TaskObserverRemove = typedef std::function<void(intptr_t )>

Definition at line 74 of file settings.h.

◆ TextureVariant

Definition at line 48 of file texture_registrar.h.

◆ UnhandledExceptionCallback

using flutter::UnhandledExceptionCallback = typedef std::function<bool(const std::string& , const std::string& )>

Definition at line 77 of file settings.h.

◆ UniqueAotDataPtr

◆ WindowProcDelegate

using flutter::WindowProcDelegate = typedef std::function<std::optional< LRESULT>(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)>

Definition at line 24 of file plugin_registrar_windows.h.

◆ WindowsRenderTarget

using flutter::WindowsRenderTarget = typedef std::variant<HWND>

Definition at line 48 of file window_binding_handler.h.

Enumeration Type Documentation

◆ AccessibilityFeatureFlag

enum flutter::AccessibilityFeatureFlag : int32_t
strong

An enum for defining the different kinds of accessibility features that can be enabled by the platform.

Must match the AccessibilityFeatureFlag enum in framework.

Enumerator
kAccessibleNavigation 
kInvertColors 
kDisableAnimations 
kBoldText 
kReduceMotion 
kHighContrast 

Definition at line 31 of file platform_configuration.h.

◆ AndroidRenderingAPI

Enumerator
kSoftware 
kOpenGLES 

Definition at line 14 of file android_context.h.

◆ Clip

Enumerator
none 
hardEdge 
antiAlias 
antiAliasWithSaveLayer 

Definition at line 40 of file layer.h.

◆ ContextType

enum flutter::ContextType
strong
Enumerator
kRender 

The context is used to render to a texture or renderbuffer.

kResource 

The context will only be used to transfer resources to and from device memory. No rendering will be performed using this context.

Definition at line 15 of file context_options.h.

15  {
16  /// The context is used to render to a texture or renderbuffer.
17  kRender,
18  /// The context will only be used to transfer resources to and from device
19  /// memory. No rendering will be performed using this context.
20  kResource,
21 };
The context is used to render to a texture or renderbuffer.

◆ DartErrorCode

Error exit codes for the Dart isolate.

Enumerator
NoError 

No error has occurred.

ApiError 

The Dart error code for an API error.

CompilationError 

The Dart error code for a compilation error.

UnknownError 

The Dart error code for an unknown error.

Definition at line 46 of file shell.h.

46  {
47  /// No error has occurred.
48  NoError = 0,
49  /// The Dart error code for an API error.
50  ApiError = 253,
51  /// The Dart error code for a compilation error.
52  CompilationError = 254,
53  /// The Dart error code for an unknown error.
54  UnknownError = 255
55 };
The Dart error code for an API error.
The Dart error code for an unknown error.
The Dart error code for a compilation error.
No error has occurred.

◆ DisplayListCompare

Enumerator
kUseBulkCompare 
kNotEqual 
kEqual 

Definition at line 36 of file display_list.cc.

36  {
37  // The Op is deferring comparisons to a bulk memcmp performed lazily
38  // across all bulk-comparable ops.
40 
41  // The Op provided a specific equals method that spotted a difference
42  kNotEqual,
43 
44  // The Op provided a specific equals method that saw no differences
45  kEqual,
46 };

◆ DisplayListOpType

Enumerator
FOR_EACH_DISPLAY_LIST_OP 

Definition at line 158 of file display_list.h.

#define DL_OP_TO_ENUM_VALUE(name)
Definition: display_list.h:157
#define FOR_EACH_DISPLAY_LIST_OP(V)
Definition: display_list.h:71

◆ DisplayUpdateType

The update type parameter that is passed to DisplayManager::HandleDisplayUpdates.

Enumerator
kStartup 

flutter::Displays that were active during start-up. A display is considered active if:

  1. The frame buffer hardware is connected.
  2. The display is drawable, e.g. it isn't being mirrored from another connected display or sleeping.

Definition at line 17 of file display_manager.h.

17  {
18  /// `flutter::Display`s that were active during start-up. A display is
19  /// considered active if:
20  /// 1. The frame buffer hardware is connected.
21  /// 2. The display is drawable, e.g. it isn't being mirrored from another
22  /// connected display or sleeping.
23  kStartup
24 };

◆ GpuAvailability

Values for |Shell::SetGpuAvailability|.

Enumerator
kAvailable 

Indicates that GPU operations should be permitted.

kFlushAndMakeUnavailable 

Indicates that the GPU is about to become unavailable, and to attempt to flush any GPU related resources now.

kUnavailable 

Indicates that the GPU is unavailable, and that no attempt should be made to even flush GPU objects until it is available again.

Definition at line 58 of file shell.h.

58  {
59  /// Indicates that GPU operations should be permitted.
60  kAvailable = 0,
61  /// Indicates that the GPU is about to become unavailable, and to attempt to
62  /// flush any GPU related resources now.
64  /// Indicates that the GPU is unavailable, and that no attempt should be made
65  /// to even flush GPU objects until it is available again.
66  kUnavailable = 2
67 };
Indicates that GPU operations should be permitted.

◆ IOSRenderingAPI

Enumerator
kSoftware 
kOpenGLES 
kMetal 

Definition at line 14 of file rendering_api_selection.h.

◆ KeyEventType

enum flutter::KeyEventType : int64_t
strong
Enumerator
kDown 
kUp 
kRepeat 

Definition at line 19 of file key_data.h.

19  : int64_t {
20  kDown = 0,
21  kUp,
22  kRepeat,
23 };
Definition: embedder.h:595

◆ MaskFilterType

Enumerator
Null 
Blur 

Definition at line 66 of file paint.cc.

66 { Null, Blur };

◆ MTLRenderTargetType

◆ MutatorType

Enumerator
clip_rect 
clip_rrect 
clip_path 
transform 
opacity 

Definition at line 24 of file embedded_views.h.

◆ PipelineConsumeResult

◆ PointerButtonMouse

Enumerator
kPointerButtonMousePrimary 
kPointerButtonMouseSecondary 
kPointerButtonMouseMiddle 
kPointerButtonMouseBack 
kPointerButtonMouseForward 

Definition at line 16 of file pointer_data.h.

◆ PointerButtonStylus

Enumerator
kPointerButtonStylusContact 
kPointerButtonStylusPrimary 
kPointerButtonStylusSecondary 

Definition at line 28 of file pointer_data.h.

◆ PointerButtonTouch

Enumerator
kPointerButtonTouchContact 

Definition at line 24 of file pointer_data.h.

24  : int64_t {
26 };

◆ PostPrerollResult

Enumerator
kSuccess 
kResubmitFrame 
kSkipAndRetryFrame 

Definition at line 248 of file embedded_views.h.

248  {
249  // Frame has successfully rasterized.
250  kSuccess,
251  // Frame is submitted twice. This is currently only used when
252  // thread configuration change occurs.
254  // Frame is dropped and a new frame with the same layer tree is
255  // attempted. This is currently only used when thread configuration
256  // change occurs.
258 };

◆ RasterStatus

enum flutter::RasterStatus
strong
Enumerator
kSuccess 
kResubmit 
kSkipAndRetry 
kEnqueuePipeline 
kFailed 
kDiscarded 
kYielded 

Definition at line 25 of file compositor_context.h.

25  {
26  // Frame has successfully rasterized.
27  kSuccess,
28  // Frame is submitted twice. This is only used on Android when
29  // switching the background surface to FlutterImageView.
30  //
31  // On Android, the first frame doesn't make the image available
32  // to the ImageReader right away. The second frame does.
33  //
34  // TODO(egarciad): https://github.com/flutter/flutter/issues/65652
35  kResubmit,
36  // Frame is dropped and a new frame with the same layer tree is
37  // attempted.
38  //
39  // This is currently used to wait for the thread merger to merge
40  // the raster and platform threads.
41  //
42  // Since the thread merger may be disabled,
44  // Frame has been successfully rasterized, but "there are additional items in
45  // the pipeline waiting to be consumed. This is currently
46  // only used when thread configuration change occurs.
48  // Failed to rasterize the frame.
49  kFailed,
50  // Layer tree was discarded due to LayerTreeDiscardCallback or inability to
51  // access the GPU.
52  kDiscarded,
53  // Drawing was yielded to allow the correct thread to draw as a result of the
54  // RasterThreadMerger.
55  kYielded,
56 };

◆ SemanticsAction

enum flutter::SemanticsAction : int32_t
strong
Enumerator
kTap 
kLongPress 
kScrollLeft 
kScrollRight 
kScrollUp 
kScrollDown 
kIncrease 
kDecrease 
kShowOnScreen 
kMoveCursorForwardByCharacter 
kMoveCursorBackwardByCharacter 
kSetSelection 
kCopy 
kCut 
kPaste 
kDidGainAccessibilityFocus 
kDidLoseAccessibilityFocus 
kCustomAction 
kDismiss 
kMoveCursorForwardByWordIndex 
kMoveCursorBackwardByWordIndex 
kSetText 

Definition at line 22 of file semantics_node.h.

22  : int32_t {
23  kTap = 1 << 0,
24  kLongPress = 1 << 1,
25  kScrollLeft = 1 << 2,
26  kScrollRight = 1 << 3,
27  kScrollUp = 1 << 4,
28  kScrollDown = 1 << 5,
29  kIncrease = 1 << 6,
30  kDecrease = 1 << 7,
31  kShowOnScreen = 1 << 8,
34  kSetSelection = 1 << 11,
35  kCopy = 1 << 12,
36  kCut = 1 << 13,
37  kPaste = 1 << 14,
40  kCustomAction = 1 << 17,
41  kDismiss = 1 << 18,
44  kSetText = 1 << 21,
45 };

◆ SemanticsFlags

enum flutter::SemanticsFlags : int32_t
strong

C/C++ representation of SemanticsFlags defined in lib/ui/semantics.dart.

Warning
This must match the SemanticsFlags enum in lib/ui/semantics.dart. See also:
Enumerator
kHasCheckedState 
kIsChecked 
kIsSelected 
kIsButton 
kIsTextField 
kIsFocused 
kHasEnabledState 
kIsEnabled 
kIsInMutuallyExclusiveGroup 
kIsHeader 
kIsObscured 
kScopesRoute 
kNamesRoute 
kIsHidden 
kIsImage 
kIsLiveRegion 
kHasToggledState 
kIsToggled 
kHasImplicitScrolling 
kIsReadOnly 
kIsFocusable 
kIsLink 
kIsSlider 
kIsKeyboardKey 

Definition at line 64 of file semantics_node.h.

64  : int32_t {
65  kHasCheckedState = 1 << 0,
66  kIsChecked = 1 << 1,
67  kIsSelected = 1 << 2,
68  kIsButton = 1 << 3,
69  kIsTextField = 1 << 4,
70  kIsFocused = 1 << 5,
71  kHasEnabledState = 1 << 6,
72  kIsEnabled = 1 << 7,
74  kIsHeader = 1 << 9,
75  kIsObscured = 1 << 10,
76  kScopesRoute = 1 << 11,
77  kNamesRoute = 1 << 12,
78  kIsHidden = 1 << 13,
79  kIsImage = 1 << 14,
80  kIsLiveRegion = 1 << 15,
81  kHasToggledState = 1 << 16,
82  kIsToggled = 1 << 17,
83  kHasImplicitScrolling = 1 << 18,
84  // The Dart API defines the following flag but it isn't used in iOS.
85  // kIsMultiline = 1 << 19,
86  kIsReadOnly = 1 << 20,
87  kIsFocusable = 1 << 21,
88  kIsLink = 1 << 22,
89  kIsSlider = 1 << 23,
90  kIsKeyboardKey = 1 << 24,
91 };

◆ StringAttributeType

enum flutter::StringAttributeType : int32_t
strong
Enumerator
kSpellOut 
kLocale 

Definition at line 26 of file string_attribute.h.

◆ TextDirection

Enumerator
rtl 
ltr 

Definition at line 14 of file text_box.h.

◆ TracingResult

Enumerator
kNotAttempted 
kEnabled 
kNotNecessary 
kDisabled 

Definition at line 17 of file ptrace_check.h.

Function Documentation

◆ __attribute__()

struct flutter::ImageMetaData flutter::__attribute__ ( (packed)  )

◆ _ComputePlatformResolvedLocale()

static void flutter::_ComputePlatformResolvedLocale ( Dart_NativeArguments  args)
static

Definition at line 445 of file platform_configuration.cc.

References ComputePlatformResolvedLocale(), result, and flutter::UIDartState::ThrowIfUIOperationsProhibited().

Referenced by flutter::PlatformConfiguration::RegisterNatives().

445  {
446  UIDartState::ThrowIfUIOperationsProhibited();
447  Dart_Handle result =
448  ComputePlatformResolvedLocale(Dart_GetNativeArgument(args, 1));
449  Dart_SetReturnValue(args, result);
450 }
G_BEGIN_DECLS FlValue * args
GAsyncResult * result
Dart_Handle ComputePlatformResolvedLocale(Dart_Handle supportedLocalesHandle)

◆ AttachJNI()

static jlong flutter::AttachJNI ( JNIEnv *  env,
jclass  clazz,
jobject  flutterJNI 
)
static

Definition at line 126 of file platform_view_android_jni_impl.cc.

References flutter::FlutterMain::Get(), and flutter::FlutterMain::GetSettings().

Referenced by RegisterApi().

126  {
127  fml::jni::JavaObjectWeakGlobalRef java_object(env, flutterJNI);
128  std::shared_ptr<PlatformViewAndroidJNI> jni_facade =
129  std::make_shared<PlatformViewAndroidJNIImpl>(java_object);
130  auto shell_holder = std::make_unique<AndroidShellHolder>(
131  FlutterMain::Get().GetSettings(), jni_facade);
132  if (shell_holder->IsValid()) {
133  return reinterpret_cast<jlong>(shell_holder.release());
134  } else {
135  return 0;
136  }
137 }

◆ BENCHMARK() [1/4]

flutter::BENCHMARK ( BM_ShellInitialization  )

◆ BENCHMARK() [2/4]

flutter::BENCHMARK ( BM_ShellShutdown  )

◆ BENCHMARK() [3/4]

◆ BENCHMARK() [4/4]

flutter::BENCHMARK ( BM_ShellInitializationAndShutdown  )

◆ BM_PathVolatilityTracker()

static void flutter::BM_PathVolatilityTracker ( benchmark::State &  state)
static

Definition at line 70 of file ui_benchmarks.cc.

References BENCHMARK(), BM_PlatformMessageResponseDartComplete(), flutter::ThreadHost::io_thread, path, flutter::ThreadHost::platform_thread, flutter::ThreadHost::raster_thread, fml::AutoResetWaitableEvent::Reset(), fml::AutoResetWaitableEvent::Signal(), UI, flutter::ThreadHost::ui_thread, and fml::AutoResetWaitableEvent::Wait().

70  {
71  ThreadHost thread_host("test",
72  ThreadHost::Type::Platform | ThreadHost::Type::RASTER |
73  ThreadHost::Type::IO | ThreadHost::Type::UI);
74  TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
75  thread_host.raster_thread->GetTaskRunner(),
76  thread_host.ui_thread->GetTaskRunner(),
77  thread_host.io_thread->GetTaskRunner());
78 
79  VolatilePathTracker tracker(task_runners.GetUITaskRunner(), true);
80 
81  while (state.KeepRunning()) {
82  std::vector<std::shared_ptr<VolatilePathTracker::TrackedPath>> paths;
83  constexpr int path_count = 1000;
84  for (int i = 0; i < path_count; i++) {
85  auto path = std::make_shared<VolatilePathTracker::TrackedPath>();
86  path->path = SkPath();
87  path->path.setIsVolatile(true);
88  paths.push_back(std::move(path));
89  }
90 
92  task_runners.GetUITaskRunner()->PostTask([&]() {
93  for (auto path : paths) {
94  tracker.Insert(path);
95  }
96  latch.Signal();
97  });
98 
99  latch.Wait();
100 
101  task_runners.GetUITaskRunner()->PostTask([&]() { tracker.OnFrame(); });
102 
103  for (int i = 0; i < path_count - 10; ++i) {
104  tracker.Erase(paths[i]);
105  }
106 
107  task_runners.GetUITaskRunner()->PostTask([&]() { tracker.OnFrame(); });
108 
109  latch.Reset();
110  task_runners.GetUITaskRunner()->PostTask([&]() { latch.Signal(); });
111  latch.Wait();
112  }
113 }
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however skia deterministic Skips the call to thus avoiding swapping out some Skia function pointers based on available CPU features This is used to obtain deterministic behavior in Skia rendering disable service auth Disable the requirement for authentication codes for communicating with the VM service start Start the application paused in the Dart debugger trace Trace Skia calls This is useful when debugging the GPU threed By Skia tracing is not enabled to reduce the number of traced events trace Filters out all trace events except those that are specified in this comma separated list of allowed prefixes cache Only cache the shader in SkSL instead of binary or GLSL This should only be used during development phases The generated SkSLs can later be used in the release build for shader precompilation at launch in order to eliminate the shader compile jank trace Trace to the system use test Running tests that layout and measure text will not yield consistent results across various platforms Enabling this option will make font resolution default to the Ahem test font on all prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive keep the shell running after the Dart script has completed disallow insecure By all insecure connections are rejected force Uses separate threads for the UI
Definition: switches.h:207
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
Definition: switches.h:57
AtkStateType state

◆ BM_PlatformMessageResponseDartComplete()

static void flutter::BM_PlatformMessageResponseDartComplete ( benchmark::State &  state)
static

Definition at line 22 of file ui_benchmarks.cc.

References flutter::DartVMRef::Create(), flutter::testing::DartFixture::CreateSettingsForFixture(), data, FML_CHECK, flutter::testing::GetDefaultKernelFilePath(), flutter::ThreadHost::io_thread, flutter::ThreadHost::platform_thread, flutter::ThreadHost::raster_thread, flutter::testing::RunDartCodeInIsolate(), UI, and flutter::ThreadHost::ui_thread.

Referenced by BM_PathVolatilityTracker().

22  {
23  ThreadHost thread_host("test",
24  ThreadHost::Type::Platform | ThreadHost::Type::RASTER |
25  ThreadHost::Type::IO | ThreadHost::Type::UI);
26  TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
27  thread_host.raster_thread->GetTaskRunner(),
28  thread_host.ui_thread->GetTaskRunner(),
29  thread_host.io_thread->GetTaskRunner());
30  Fixture fixture;
31  auto settings = fixture.CreateSettingsForFixture();
32  auto vm_ref = DartVMRef::Create(settings);
33  auto isolate =
34  testing::RunDartCodeInIsolate(vm_ref, settings, task_runners, "main", {},
36 
37  while (state.KeepRunning()) {
38  state.PauseTiming();
39  bool successful = isolate->RunInIsolateScope([&]() -> bool {
40  // Simulate a message of 3 MB
41  std::vector<uint8_t> data(3 << 20, 0);
42  std::unique_ptr<fml::Mapping> mapping =
43  std::make_unique<fml::DataMapping>(data);
44 
45  Dart_Handle library = Dart_RootLibrary();
46  Dart_Handle closure =
47  Dart_GetField(library, Dart_NewStringFromCString("messageCallback"));
48 
49  auto message = fml::MakeRefCounted<PlatformMessageResponseDart>(
50  tonic::DartPersistentValue(isolate->get(), closure),
51  thread_host.ui_thread->GetTaskRunner());
52 
53  message->Complete(std::move(mapping));
54 
55  return true;
56  });
57  FML_CHECK(successful);
58  state.ResumeTiming();
59 
60  // We skip timing everything above because the copy triggered by
61  // message->Complete is a task posted on the UI thread. The following wait
62  // for a UI task would let us know when that copy is done.
63  std::promise<bool> completed;
64  task_runners.GetUITaskRunner()->PostTask(
65  [&completed] { completed.set_value(true); });
66  completed.get_future().wait();
67  }
68 }
std::string GetDefaultKernelFilePath()
Returns the default path to kernel_blob.bin. This file is within the directory returned by GetFixture...
Definition: testing.cc:17
std::unique_ptr< AutoIsolateShutdown > RunDartCodeInIsolate(DartVMRef &vm_ref, const Settings &settings, const TaskRunners &task_runners, std::string entrypoint, const std::vector< std::string > &args, const std::string &kernel_file_path, fml::WeakPtr< IOManager > io_manager, std::shared_ptr< VolatilePathTracker > volatile_path_tracker)
std::function< void()> closure
Definition: closure.h:14
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot data
Definition: switches.h:41
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 observatory The hostname IP address on which the Dart Observatory should be served If not defaults to or::depending on whether ipv6 is specified disable Disable the Dart Observatory The observatory is never available in release mode Bind to the IPv6 localhost address for the Dart Observatory Ignored if observatory host is set endless trace Enable an endless trace buffer The default is a ring buffer This is useful when very old events need to viewed For during application launch Memory usage will continue to grow indefinitely however skia deterministic Skips the call to thus avoiding swapping out some Skia function pointers based on available CPU features This is used to obtain deterministic behavior in Skia rendering disable service auth Disable the requirement for authentication codes for communicating with the VM service start Start the application paused in the Dart debugger trace Trace Skia calls This is useful when debugging the GPU threed By Skia tracing is not enabled to reduce the number of traced events trace Filters out all trace events except those that are specified in this comma separated list of allowed prefixes cache Only cache the shader in SkSL instead of binary or GLSL This should only be used during development phases The generated SkSLs can later be used in the release build for shader precompilation at launch in order to eliminate the shader compile jank trace Trace to the system use test Running tests that layout and measure text will not yield consistent results across various platforms Enabling this option will make font resolution default to the Ahem test font on all prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive keep the shell running after the Dart script has completed disallow insecure By all insecure connections are rejected force Uses separate threads for the UI
Definition: switches.h:207
#define FML_CHECK(condition)
Definition: logging.h:68
AtkStateType state

◆ BM_ShellInitialization()

static void flutter::BM_ShellInitialization ( benchmark::State &  state)
static

Definition at line 99 of file shell_benchmarks.cc.

References BENCHMARK(), and StartupAndShutdownShell().

99  {
100  while (state.KeepRunning()) {
101  StartupAndShutdownShell(state, true, false);
102  }
103 }
static void StartupAndShutdownShell(benchmark::State &state, bool measure_startup, bool measure_shutdown)
AtkStateType state

◆ BM_ShellInitializationAndShutdown()

static void flutter::BM_ShellInitializationAndShutdown ( benchmark::State &  state)
static

Definition at line 115 of file shell_benchmarks.cc.

References BENCHMARK(), and StartupAndShutdownShell().

115  {
116  while (state.KeepRunning()) {
117  StartupAndShutdownShell(state, true, true);
118  }
119 }
static void StartupAndShutdownShell(benchmark::State &state, bool measure_startup, bool measure_shutdown)
AtkStateType state

◆ BM_ShellShutdown()

static void flutter::BM_ShellShutdown ( benchmark::State &  state)
static

Definition at line 107 of file shell_benchmarks.cc.

References BENCHMARK(), and StartupAndShutdownShell().

107  {
108  while (state.KeepRunning()) {
109  StartupAndShutdownShell(state, false, true);
110  }
111 }
static void StartupAndShutdownShell(benchmark::State &state, bool measure_startup, bool measure_shutdown)
AtkStateType state

◆ BUILTIN_NATIVE_LIST()

flutter::BUILTIN_NATIVE_LIST ( DECLARE_FUNCTION  )

◆ CanRasterizeRect()

static bool flutter::CanRasterizeRect ( const SkRect &  cull_rect)
static

Definition at line 48 of file raster_cache.cc.

References FML_LOG.

Referenced by IsDisplayListWorthRasterizing(), and IsPictureWorthRasterizing().

48  {
49  if (cull_rect.isEmpty()) {
50  // No point in ever rasterizing an empty display list.
51  return false;
52  }
53 
54  if (!cull_rect.isFinite()) {
55  // Cannot attempt to rasterize into an infinitely large surface.
56  FML_LOG(INFO) << "Attempted to raster cache non-finite display list";
57  return false;
58  }
59 
60  return true;
61 }
#define FML_LOG(severity)
Definition: logging.h:65

◆ Canvas_constructor()

static void flutter::Canvas_constructor ( Dart_NativeArguments  args)
static

Definition at line 28 of file canvas.cc.

References flutter::Canvas::Create(), tonic::DartCallConstructor(), IMPLEMENT_WRAPPERTYPEINFO(), and flutter::UIDartState::ThrowIfUIOperationsProhibited().

Referenced by flutter::Canvas::RegisterNatives().

28  {
29  UIDartState::ThrowIfUIOperationsProhibited();
30  DartCallConstructor(&Canvas::Create, args);
31 }
G_BEGIN_DECLS FlValue * args
void DartCallConstructor(Sig func, Dart_NativeArguments args)
Definition: dart_args.h:218

◆ CastToGLContext()

static IOSContextGL* flutter::CastToGLContext ( const std::shared_ptr< IOSContext > &  context)
static

Definition at line 13 of file ios_surface_gl.mm.

Referenced by flutter::IOSSurfaceGL::CreateGPUSurface(), and flutter::IOSSurfaceGL::IOSSurfaceGL().

13  {
14  return reinterpret_cast<IOSContextGL*>(context.get());
15 }

◆ CastToMetalContext()

static IOSContextMetal* flutter::CastToMetalContext ( const std::shared_ptr< IOSContext > &  context)
static

Definition at line 13 of file ios_surface_metal.mm.

Referenced by flutter::IOSSurfaceMetal::IOSSurfaceMetal().

13  {
14  return reinterpret_cast<IOSContextMetal*>(context.get());
15 }

◆ CheckEncodeDecode()

static void flutter::CheckEncodeDecode ( const EncodableValue value,
const std::vector< uint8_t > &  expected_encoding,
const StandardCodecSerializer serializer = nullptr,
std::function< bool(const EncodableValue &a, const EncodableValue &b)>  custom_comparator = nullptr 
)
static

Definition at line 34 of file standard_message_codec_unittests.cc.

References flutter::MessageCodec< T >::DecodeMessage(), flutter::MessageCodec< T >::EncodeMessage(), and flutter::StandardMessageCodec::GetInstance().

Referenced by TEST().

39  {
40  const StandardMessageCodec& codec =
41  StandardMessageCodec::GetInstance(serializer);
42  auto encoded = codec.EncodeMessage(value);
43  ASSERT_TRUE(encoded);
44  EXPECT_EQ(*encoded, expected_encoding);
45 
46  auto decoded = codec.DecodeMessage(*encoded);
47  if (custom_comparator) {
48  EXPECT_TRUE(custom_comparator(value, *decoded));
49  } else {
50  EXPECT_EQ(value, *decoded);
51  }
52 }
uint8_t value

◆ CheckEncodeDecodeWithEncodePrefix()

static void flutter::CheckEncodeDecodeWithEncodePrefix ( const EncodableValue value,
const std::vector< uint8_t > &  expected_encoding_prefix,
size_t  expected_encoding_length 
)
static

Definition at line 59 of file standard_message_codec_unittests.cc.

References flutter::MessageCodec< T >::DecodeMessage(), flutter::MessageCodec< T >::EncodeMessage(), and flutter::StandardMessageCodec::GetInstance().

Referenced by TEST().

62  {
63  EXPECT_TRUE(std::holds_alternative<EncodableMap>(value));
64  const StandardMessageCodec& codec = StandardMessageCodec::GetInstance();
65  auto encoded = codec.EncodeMessage(value);
66  ASSERT_TRUE(encoded);
67 
68  EXPECT_EQ(encoded->size(), expected_encoding_length);
69  ASSERT_GT(encoded->size(), expected_encoding_prefix.size());
70  EXPECT_TRUE(std::equal(
71  encoded->begin(), encoded->begin() + expected_encoding_prefix.size(),
72  expected_encoding_prefix.begin(), expected_encoding_prefix.end()));
73 
74  auto decoded = codec.DecodeMessage(*encoded);
75 
76  EXPECT_EQ(value, *decoded);
77 }
uint8_t value

◆ ChooseEGLConfiguration()

static EGLResult<EGLConfig> flutter::ChooseEGLConfiguration ( EGLDisplay  display)
static

Definition at line 73 of file android_context_gl.cc.

Referenced by flutter::AndroidContextGL::AndroidContextGL().

73  {
74  EGLint attributes[] = {
75  // clang-format off
76  EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
77  EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
78  EGL_RED_SIZE, 8,
79  EGL_GREEN_SIZE, 8,
80  EGL_BLUE_SIZE, 8,
81  EGL_ALPHA_SIZE, 8,
82  EGL_DEPTH_SIZE, 0,
83  EGL_STENCIL_SIZE, 0,
84  EGL_NONE, // termination sentinel
85  // clang-format on
86  };
87 
88  EGLint config_count = 0;
89  EGLConfig egl_config = nullptr;
90 
91  if (eglChooseConfig(display, attributes, &egl_config, 1, &config_count) !=
92  EGL_TRUE) {
93  return {false, nullptr};
94  }
95 
96  bool success = config_count > 0 && egl_config != nullptr;
97 
98  return {success, success ? egl_config : nullptr};
99 }

◆ CleanupMessageData()

static void flutter::CleanupMessageData ( JNIEnv *  env,
jobject  jcaller,
jlong  message_data 
)
static

Definition at line 437 of file platform_view_android_jni_impl.cc.

Referenced by RegisterApi().

439  {
440  // Called from any thread.
441  free(reinterpret_cast<void*>(message_data));
442 }

◆ ColorFilter_constructor()

static void flutter::ColorFilter_constructor ( Dart_NativeArguments  args)
static

Definition at line 17 of file color_filter.cc.

References flutter::ColorFilter::Create(), tonic::DartCallConstructor(), IMPLEMENT_WRAPPERTYPEINFO(), and flutter::UIDartState::ThrowIfUIOperationsProhibited().

Referenced by flutter::ColorFilter::RegisterNatives().

17  {
18  UIDartState::ThrowIfUIOperationsProhibited();
19  DartCallConstructor(&ColorFilter::Create, args);
20 }
G_BEGIN_DECLS FlValue * args
void DartCallConstructor(Sig func, Dart_NativeArguments args)
Definition: dart_args.h:218

◆ CommandLineFromNSProcessInfo()

fml::CommandLine flutter::CommandLineFromNSProcessInfo ( )

Definition at line 11 of file command_line.mm.

References fml::CommandLineFromIterators().

Referenced by FLTDefaultSettingsForBundle().

11  {
12  std::vector<std::string> args_vector;
13 
14  for (NSString* arg in [NSProcessInfo processInfo].arguments) {
15  args_vector.emplace_back(arg.UTF8String);
16  }
17 
18  return fml::CommandLineFromIterators(args_vector.begin(), args_vector.end());
19 }
CommandLine CommandLineFromIterators(InputIterator first, InputIterator last)
Definition: command_line.h:203

◆ CompareOps()

static bool flutter::CompareOps ( uint8_t *  ptrA,
uint8_t *  endA,
uint8_t *  ptrB,
uint8_t *  endB 
)
static

Definition at line 915 of file display_list.cc.

References DL_OP_EQUALS, FML_DCHECK, FOR_EACH_DISPLAY_LIST_OP, kEqual, kNotEqual, kUseBulkCompare, result, and flutter::DLOp::size.

Referenced by flutter::DisplayList::Equals().

918  {
919  // These conditions are checked by the caller...
920  FML_DCHECK((endA - ptrA) == (endB - ptrB));
921  FML_DCHECK(ptrA != ptrB);
922  uint8_t* bulkStartA = ptrA;
923  uint8_t* bulkStartB = ptrB;
924  while (ptrA < endA && ptrB < endB) {
925  auto opA = reinterpret_cast<const DLOp*>(ptrA);
926  auto opB = reinterpret_cast<const DLOp*>(ptrB);
927  if (opA->type != opB->type || opA->size != opB->size) {
928  return false;
929  }
930  ptrA += opA->size;
931  ptrB += opB->size;
932  FML_DCHECK(ptrA <= endA);
933  FML_DCHECK(ptrB <= endB);
935  switch (opA->type) {
936 #define DL_OP_EQUALS(name) \
937  case DisplayListOpType::k##name: \
938  result = static_cast<const name##Op*>(opA)->equals( \
939  static_cast<const name##Op*>(opB)); \
940  break;
941 
943 
944 #undef DL_OP_EQUALS
945 
946  default:
947  FML_DCHECK(false);
948  return false;
949  }
950  switch (result) {
951  case DisplayListCompare::kNotEqual:
952  return false;
953  case DisplayListCompare::kUseBulkCompare:
954  break;
955  case DisplayListCompare::kEqual:
956  // Check if we have a backlog of bytes to bulk compare and then
957  // reset the bulk compare pointers to the address following this op
958  auto bulkBytes = reinterpret_cast<const uint8_t*>(opA) - bulkStartA;
959  if (bulkBytes > 0) {
960  if (memcmp(bulkStartA, bulkStartB, bulkBytes) != 0) {
961  return false;
962  }
963  }
964  bulkStartA = ptrA;
965  bulkStartB = ptrB;
966  break;
967  }
968  }
969  if (ptrA != endA || ptrB != endB) {
970  return false;
971  }
972  if (bulkStartA < ptrA) {
973  // Perform a final bulk compare if we have remaining bytes waiting
974  if (memcmp(bulkStartA, bulkStartB, ptrA - bulkStartA) != 0) {
975  return false;
976  }
977  }
978  return true;
979 }
#define FML_DCHECK(condition)
Definition: logging.h:86
GAsyncResult * result
#define DL_OP_EQUALS(name)
DisplayListCompare
Definition: display_list.cc:36
#define FOR_EACH_DISPLAY_LIST_OP(V)
Definition: display_list.h:71

◆ ComputePlatformResolvedLocale()

Dart_Handle flutter::ComputePlatformResolvedLocale ( Dart_Handle  supportedLocalesHandle)

Definition at line 431 of file platform_configuration.cc.

References flutter::PlatformConfiguration::client(), flutter::PlatformConfigurationClient::ComputePlatformResolvedLocale(), flutter::UIDartState::Current(), flutter::UIDartState::platform_configuration(), and tonic::ToDart().

Referenced by _ComputePlatformResolvedLocale(), flutter::Engine::GetRuntimeController(), and flutter::RuntimeController::GetSnapshotDelegate().

431  {
432  std::vector<std::string> supportedLocales =
434  supportedLocalesHandle);
435 
436  std::vector<std::string> results =
437  *UIDartState::Current()
438  ->platform_configuration()
439  ->client()
440  ->ComputePlatformResolvedLocale(supportedLocales);
441 
443 }
Dart_Handle ToDart(const T &object)

◆ ConvertChar32ToUtf8()

std::string flutter::ConvertChar32ToUtf8 ( char32_t  ch)

Definition at line 51 of file keyboard_key_embedder_handler.cc.

References result.

Referenced by flutter::KeyboardKeyEmbedderHandler::KeyboardHook(), and flutter::testing::TEST().

51  {
52  std::string result;
53  assert(0 <= ch && ch <= 0x10FFFF);
54  if (ch <= 0x007F) {
55  result.push_back(ch);
56  } else if (ch <= 0x07FF) {
57  result.push_back(0b11000000 + _GetBit(ch, 11, 6));
58  result.push_back(0b10000000 + _GetBit(ch, 6, 0));
59  } else if (ch <= 0xFFFF) {
60  result.push_back(0b11100000 + _GetBit(ch, 16, 12));
61  result.push_back(0b10000000 + _GetBit(ch, 12, 6));
62  result.push_back(0b10000000 + _GetBit(ch, 6, 0));
63  } else {
64  result.push_back(0b11110000 + _GetBit(ch, 21, 18));
65  result.push_back(0b10000000 + _GetBit(ch, 18, 12));
66  result.push_back(0b10000000 + _GetBit(ch, 12, 6));
67  result.push_back(0b10000000 + _GetBit(ch, 6, 0));
68  }
69  return result;
70 }
GAsyncResult * result

◆ ConvertMappingToNSData()

NSData * flutter::ConvertMappingToNSData ( fml::MallocMapping  buffer)

Definition at line 34 of file buffer_conversions.mm.

References fml::MallocMapping::GetSize(), length, fml::MallocMapping::Release(), and fml::size().

Referenced by flutter::PlatformMessageHandlerIos::HandlePlatformMessage().

34  {
35  size_t size = buffer.GetSize();
36  return [NSData dataWithBytesNoCopy:buffer.Release() length:size];
37 }
constexpr std::size_t size(T(&array)[N])
Definition: size.h:13
uint8_t * Release()
Definition: mapping.cc:153
size_t GetSize() const override
Definition: mapping.cc:141
size_t length

◆ ConvertMutation() [1/4]

static std::unique_ptr<FlutterPlatformViewMutation> flutter::ConvertMutation ( double  opacity)
static

Definition at line 41 of file embedder_layers.cc.

References kFlutterPlatformViewMutationTypeOpacity, opacity, FlutterPlatformViewMutation::opacity, and FlutterPlatformViewMutation::type.

Referenced by flutter::EmbedderLayers::PushPlatformViewLayer().

42  {
43  FlutterPlatformViewMutation mutation = {};
45  mutation.opacity = opacity;
46  return std::make_unique<FlutterPlatformViewMutation>(mutation);
47 }
FlutterPlatformViewMutationType type
The type of the mutation described by the subsequent union.
Definition: embedder.h:1009

◆ ConvertMutation() [2/4]

static std::unique_ptr<FlutterPlatformViewMutation> flutter::ConvertMutation ( const SkRect &  rect)
static

Definition at line 49 of file embedder_layers.cc.

References FlutterRect::bottom, FlutterPlatformViewMutation::clip_rect, kFlutterPlatformViewMutationTypeClipRect, FlutterRect::left, FlutterRect::right, FlutterRect::top, and FlutterPlatformViewMutation::type.

50  {
51  FlutterPlatformViewMutation mutation = {};
53  mutation.clip_rect.left = rect.left();
54  mutation.clip_rect.top = rect.top();
55  mutation.clip_rect.right = rect.right();
56  mutation.clip_rect.bottom = rect.bottom();
57  return std::make_unique<FlutterPlatformViewMutation>(mutation);
58 }
double right
Definition: embedder.h:336
double top
Definition: embedder.h:335
double left
Definition: embedder.h:334
double bottom
Definition: embedder.h:337
FlutterPlatformViewMutationType type
The type of the mutation described by the subsequent union.
Definition: embedder.h:1009

◆ ConvertMutation() [3/4]

static std::unique_ptr<FlutterPlatformViewMutation> flutter::ConvertMutation ( const SkRRect &  rrect)
static

Definition at line 67 of file embedder_layers.cc.

References FlutterRect::bottom, FlutterPlatformViewMutation::clip_rounded_rect, kFlutterPlatformViewMutationTypeClipRoundedRect, FlutterRect::left, FlutterRoundedRect::lower_left_corner_radius, FlutterRoundedRect::lower_right_corner_radius, FlutterRoundedRect::rect, FlutterRect::right, FlutterRect::top, FlutterPlatformViewMutation::type, FlutterRoundedRect::upper_left_corner_radius, FlutterRoundedRect::upper_right_corner_radius, and VectorToSize().

68  {
69  FlutterPlatformViewMutation mutation = {};
71  const auto& rect = rrect.rect();
72  mutation.clip_rounded_rect.rect.left = rect.left();
73  mutation.clip_rounded_rect.rect.top = rect.top();
74  mutation.clip_rounded_rect.rect.right = rect.right();
75  mutation.clip_rounded_rect.rect.bottom = rect.bottom();
77  VectorToSize(rrect.radii(SkRRect::Corner::kUpperLeft_Corner));
79  VectorToSize(rrect.radii(SkRRect::Corner::kUpperRight_Corner));
81  VectorToSize(rrect.radii(SkRRect::Corner::kLowerRight_Corner));
83  VectorToSize(rrect.radii(SkRRect::Corner::kLowerLeft_Corner));
84  return std::make_unique<FlutterPlatformViewMutation>(mutation);
85 }
static FlutterSize VectorToSize(const SkVector &vector)
FlutterSize upper_left_corner_radius
Definition: embedder.h:349
FlutterSize upper_right_corner_radius
Definition: embedder.h:350
double right
Definition: embedder.h:336
FlutterSize lower_right_corner_radius
Definition: embedder.h:351
double top
Definition: embedder.h:335
double left
Definition: embedder.h:334
double bottom
Definition: embedder.h:337
FlutterRoundedRect clip_rounded_rect
Definition: embedder.h:1013
FlutterPlatformViewMutationType type
The type of the mutation described by the subsequent union.
Definition: embedder.h:1009
FlutterSize lower_left_corner_radius
Definition: embedder.h:352
FlutterRect rect
Definition: embedder.h:348

◆ ConvertMutation() [4/4]