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  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  AndroidSurfaceVulkan
 
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
 
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  DirectoryAssetBundle
 
class  Dispatcher
 
class  Display
 
class  DisplayHelperWinUWP
 
class  DisplayList
 
class  DisplayListBoundsCalculator
 
class  DisplayListBuilder
 
class  DisplayListCanvasDispatcher
 
class  DisplayListCanvasRecorder
 
class  DisplayListLayer
 
class  DisplayManager
 Manages lifecycle of the connected displays. This class is thread-safe. More...
 
struct  DLOp
 
struct  DrawArcOp
 
struct  DrawColorOp
 
struct  DrawDisplayListOp
 
struct  DrawImageLatticeOp
 
struct  DrawImageNineOp
 
struct  DrawImageOp
 
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  FrameTiming
 
class  FrameTimingsRecorder
 
class  GamepadCursorWinUWP
 
class  GamepadWinUWP
 
class  GLContextDefaultResult
 
class  GLContextResult
 
class  GLContextSwitch
 
struct  GLFrameInfo
 
class  GLFWEventLoop
 
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 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
 
class  MatrixDecomposition
 
struct  MemoryUsageInfo
 Memory usage stats. dirty_memory_usage is the 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 physicaal 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  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  PlatformMessageResponse
 
class  PlatformMessageResponseAndroid
 
class  PlatformMessageResponseDart
 
class  PlatformMessageResponseDarwin
 
class  PlatformMessageRouter
 
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
 
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  ServiceProtocol
 
struct  SetBlendModeOp
 
struct  SetColorOp
 
struct  SetDrawStyleOp
 
struct  SetMiterLimitOp
 
struct  SetStrokeWidthOp
 
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
 
struct  TextBox
 
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  Transform2x3Op
 
struct  Transform3x3Op
 
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 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 >
 
typedef std::function< void(bool)> KeyDataResponse
 
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 JavaWeakGlobalRef = 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
 
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
}
 
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,
  AndroidRenderingAPI::kVulkan
}
 
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)
 
static SkV3 SkV3Combine (const SkV3 &a, float a_scale, const SkV3 &b, float b_scale)
 
static void SkV3Normalize (SkV3 *v)
 
void DrawCheckerboard (SkCanvas *canvas, SkColor c1, SkColor c2, int size)
 
void DrawCheckerboard (SkCanvas *canvas, const SkRect &rect)
 
static bool CanRasterizePicture (SkPicture *picture)
 
static bool CanRasterizeDisplayList (DisplayList *display_list)
 
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 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 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)
 
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 int64_t 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, 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)
 
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::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(SnapshotAssetPath
 
DEF_SWITCHES_START snapshot asset Path to the directory containing the four files specified by VmSnapshotInstructions and IsolateSnapshotInstructions DEF_SWITCH (VmSnapshotData, "vm-snapshot-data", "The VM snapshot data that will be memory mapped as read-only. " "SnapshotAssetPath must be present.") DEF_SWITCH(VmSnapshotInstructions
 
DEF_SWITCHES_START snapshot asset Path to the directory containing the four files specified by VmSnapshotInstructions and IsolateSnapshotInstructions vm snapshot The VM instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present DEF_SWITCH (IsolateSnapshotData, "isolate-snapshot-data", "The isolate snapshot data that will be memory mapped as read-only. " "SnapshotAssetPath must be present.") DEF_SWITCH(IsolateSnapshotInstructions
 
DEF_SWITCHES_START snapshot asset Path to the directory containing the four files specified by VmSnapshotInstructions and IsolateSnapshotInstructions vm snapshot The VM instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present isolate snapshot The isolate instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present DEF_SWITCH (CacheDirPath, "cache-dir-path", "Path to the cache directory. " "This is different from the persistent_cache_path in embedder.h, " "which is used for Skia shader cache.") DEF_SWITCH(ICUSymbolPrefix
 
DEF_SWITCHES_START snapshot asset Path to the directory containing the four files specified by VmSnapshotInstructions and IsolateSnapshotInstructions vm snapshot The VM instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present isolate snapshot The isolate instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present icu symbol Prefix for the symbols representing ICU data linked into the Flutter library DEF_SWITCH (ICUNativeLibPath, "icu-native-lib-path", "Path to the library file that exports the ICU data.") DEF_SWITCH(DartFlags
 
DEF_SWITCHES_START snapshot asset Path to the directory containing the four files specified by VmSnapshotInstructions and IsolateSnapshotInstructions vm snapshot The VM instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present isolate snapshot The isolate instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present icu symbol Prefix for the symbols representing ICU data linked into the Flutter library dart Flags passed directly to the Dart VM without being interpreted by the Flutter shell DEF_SWITCH (DeviceObservatoryHost, "observatory-host", "The hostname/IP address on which the Dart Observatory should " "be served. If not set, defaults to 127.0.0.1 or ::1 depending on " "whether --ipv6 is specified.") DEF_SWITCH(DeviceObservatoryPort
 
DEF_SWITCHES_START snapshot asset Path to the directory containing the four files specified by VmSnapshotInstructions and IsolateSnapshotInstructions vm snapshot The VM instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present isolate snapshot The isolate instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present icu symbol Prefix for the symbols representing ICU data linked into the Flutter library dart Flags passed directly to the Dart VM without being interpreted by the Flutter shell observatory A custom Dart Observatory port The default is to pick a randomly available open port DEF_SWITCH (DisableObservatory, "disable-observatory", "Disable the Dart Observatory. The observatory is never available " "in release mode.") DEF_SWITCH(DisableObservatoryPublication
 
DEF_SWITCHES_START snapshot asset Path to the directory containing the four files specified by VmSnapshotInstructions and IsolateSnapshotInstructions vm snapshot The VM instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present isolate snapshot The isolate instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present icu symbol Prefix for the symbols representing ICU data linked into the Flutter library dart Flags passed directly to the Dart VM without being interpreted by the Flutter shell observatory A custom Dart Observatory port The default is to pick a randomly available open port disable observatory Disable mDNS Dart Observatory publication DEF_SWITCH (IPv6, "ipv6", "Bind to the IPv6 localhost address for the Dart Observatory. " "Ignored if --observatory-host is set.") DEF_SWITCH(EnableDartProfiling
 
DEF_SWITCHES_START snapshot asset Path to the directory containing the four files specified by VmSnapshotInstructions and IsolateSnapshotInstructions vm snapshot The VM instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present isolate snapshot The isolate instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present icu symbol Prefix for the symbols representing ICU data linked into the Flutter library dart Flags passed directly to the Dart VM without being interpreted by the Flutter shell observatory A custom Dart Observatory port The default is to pick a randomly available open port disable observatory Disable mDNS Dart Observatory publication enable dart Enable Dart profiling Profiling information can be viewed from the observatory DEF_SWITCH (EndlessTraceBuffer, "endless-trace-buffer", "Enable an endless trace buffer. The default is a ring buffer. " "This is useful when very old events need to viewed. For example, " "during application launch. Memory usage will continue to grow " "indefinitely however.") DEF_SWITCH(EnableSoftwareRendering
 
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, bool create_onscreen_surface)
 
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, jboolean is_background_view)
 
static void DestroyJNI (JNIEnv *env, jobject jcaller, jlong shell_holder)
 
static jobject SpawnJNI (JNIEnv *env, jobject jcaller, jlong shell_holder, jstring jEntrypoint, jstring jLibraryUrl)
 
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)
 
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)
 
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 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, 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, 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 (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, 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 FlutterPointerDeviceKind GetFlutterPointerDeviceKind ()
 
static bool SurfaceWillUpdate (size_t cur_width, size_t cur_height, size_t target_width, size_t target_height)
 
static bool IsValid (double value)
 
static bool isEasciiPrintable (int codeUnit)
 
static uint64_t toLower (uint64_t n)
 
static uint16_t normalizeScancode (int windowsScanCode, bool extended)
 
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)
 
 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_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 const char *kDartFuchsiaTraceArgs [] FML_ALLOW_UNUSED_TYPE
 
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 snapshot asset path
 
DEF_SWITCHES_START snapshot asset Path to the directory containing the four files specified by VmSnapshotData
 
DEF_SWITCHES_START snapshot asset Path to the directory containing the four files specified by VmSnapshotInstructions
 
DEF_SWITCHES_START snapshot asset Path to the directory containing the four files specified by VmSnapshotInstructions and IsolateSnapshotInstructions vm snapshot instr
 
DEF_SWITCHES_START snapshot asset Path to the directory containing the four files specified by VmSnapshotInstructions and IsolateSnapshotInstructions vm snapshot The VM instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present isolate snapshot The isolate instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present icu symbol prefix
 
DEF_SWITCHES_START snapshot asset Path to the directory containing the four files specified by VmSnapshotInstructions and IsolateSnapshotInstructions vm snapshot The VM instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present isolate snapshot The isolate instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present icu symbol Prefix for the symbols representing ICU data linked into the Flutter library dart flags
 
DEF_SWITCHES_START snapshot asset Path to the directory containing the four files specified by VmSnapshotInstructions and IsolateSnapshotInstructions vm snapshot The VM instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present isolate snapshot The isolate instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present icu symbol Prefix for the symbols representing ICU data linked into the Flutter library dart Flags passed directly to the Dart VM without being interpreted by the Flutter shell observatory port
 
DEF_SWITCHES_START snapshot asset Path to the directory containing the four files specified by VmSnapshotInstructions and IsolateSnapshotInstructions vm snapshot The VM instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present isolate snapshot The isolate instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present icu symbol Prefix for the symbols representing ICU data linked into the Flutter library dart Flags passed directly to the Dart VM without being interpreted by the Flutter shell observatory A custom Dart Observatory port The default is to pick a randomly available open port disable observatory publication
 
DEF_SWITCHES_START snapshot asset Path to the directory containing the four files specified by VmSnapshotInstructions and IsolateSnapshotInstructions vm snapshot The VM instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present isolate snapshot The isolate instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present icu symbol Prefix for the symbols representing ICU data linked into the Flutter library dart Flags passed directly to the Dart VM without being interpreted by the Flutter shell observatory A custom Dart Observatory port The default is to pick a randomly available open port disable observatory Disable mDNS Dart Observatory publication enable dart profiling
 
DEF_SWITCHES_START snapshot asset Path to the directory containing the four files specified by VmSnapshotInstructions and IsolateSnapshotInstructions vm snapshot The VM instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present isolate snapshot The isolate instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present icu symbol Prefix for the symbols representing ICU data linked into the Flutter library dart Flags passed directly to the Dart VM without being interpreted by the Flutter shell observatory A custom Dart Observatory port The default is to pick a randomly available open port disable observatory Disable mDNS Dart Observatory publication enable dart Enable Dart profiling Profiling information can be viewed from the observatory enable software rendering
 
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_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_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
 
constexpr int32_t kRootNode = 0
 
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
 
constexpr uint32_t kWindowFrameBufferID = 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 17 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 14 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 16 of file android_context_gl.cc.

◆ EncodableList

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

Definition at line 92 of file encodable_value.h.

◆ EncodableMap

Definition at line 93 of file encodable_value.h.

◆ ExternalTextureGLState

◆ FrameRasterizedCallback

Definition at line 69 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.

◆ 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.

◆ JavaWeakGlobalRef

using flutter::JavaWeakGlobalRef = typedef std::nullptr_t

Definition at line 25 of file platform_view_android_jni.h.

◆ KeyDataResponse

Definition at line 24 of file platform_configuration.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 61 of file settings.h.

◆ MappingCallback

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

Definition at line 65 of file settings.h.

◆ Mappings

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

Definition at line 66 of file settings.h.

◆ MappingsCallback

Definition at line 67 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.

◆ 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 174 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 147 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 54 of file settings.h.

◆ TaskObserverRemove

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

Definition at line 55 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 58 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 33 of file platform_configuration.h.

◆ AndroidRenderingAPI

Enumerator
kSoftware 
kOpenGLES 
kVulkan 

Definition at line 13 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 39 of file display_list.cc.

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

◆ DisplayListOpType

Enumerator
FOR_EACH_DISPLAY_LIST_OP 

Definition at line 154 of file display_list.h.

#define DL_OP_TO_ENUM_VALUE(name)
Definition: display_list.h:153
#define FOR_EACH_DISPLAY_LIST_OP(V)
Definition: display_list.h:66

◆ 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:594

◆ 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 25 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 249 of file embedded_views.h.

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

◆ RasterStatus

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

Definition at line 24 of file compositor_context.h.

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

◆ 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 24 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 481 of file platform_configuration.cc.

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

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

481  {
482  UIDartState::ThrowIfUIOperationsProhibited();
483  Dart_Handle result =
484  ComputePlatformResolvedLocale(Dart_GetNativeArgument(args, 1));
485  Dart_SetReturnValue(args, result);
486 }
G_BEGIN_DECLS FlValue * args
GAsyncResult * result
Dart_Handle ComputePlatformResolvedLocale(Dart_Handle supportedLocalesHandle)

◆ AttachJNI()

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

Definition at line 121 of file platform_view_android_jni_impl.cc.

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

Referenced by RegisterApi().

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

◆ 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(), 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 snapshot asset path
Definition: switches.h:32
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::FixtureTest::CreateSettingsForFixture(), FML_CHECK, flutter::testing::GetDefaultKernelFilePath(), flutter::ThreadHost::io_thread, message, flutter::ThreadHost::platform_thread, flutter::ThreadHost::raster_thread, flutter::testing::RunDartCodeInIsolate(), 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
#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  )

◆ CanRasterizeDisplayList()

static bool flutter::CanRasterizeDisplayList ( DisplayList display_list)
static

Definition at line 66 of file raster_cache.cc.

References flutter::DisplayList::bounds(), and FML_LOG.

Referenced by IsDisplayListWorthRasterizing().

66  {
67  if (display_list == nullptr) {
68  return false;
69  }
70 
71  const SkRect cull_rect = display_list->bounds();
72 
73  if (cull_rect.isEmpty()) {
74  // No point in ever rasterizing an empty display list.
75  return false;
76  }
77 
78  if (!cull_rect.isFinite()) {
79  // Cannot attempt to rasterize into an infinitely large surface.
80  FML_LOG(INFO) << "Attempted to raster cache non-finite display list";
81  return false;
82  }
83 
84  return true;
85 }
#define FML_LOG(severity)
Definition: logging.h:65

◆ CanRasterizePicture()

static bool flutter::CanRasterizePicture ( SkPicture *  picture)
static

Definition at line 45 of file raster_cache.cc.

References FML_LOG.

Referenced by IsPictureWorthRasterizing().

45  {
46  if (picture == nullptr) {
47  return false;
48  }
49 
50  const SkRect cull_rect = picture->cullRect();
51 
52  if (cull_rect.isEmpty()) {
53  // No point in ever rasterizing an empty picture.
54  return false;
55  }
56 
57  if (!cull_rect.isFinite()) {
58  // Cannot attempt to rasterize into an infinitely large surface.
59  FML_LOG(INFO) << "Attempted to raster cache non-finite picture";
60  return false;
61  }
62 
63  return true;
64 }
#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 72 of file android_context_gl.cc.

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

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

◆ 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:201

◆ CompareOps()

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

Definition at line 879 of file display_list.cc.

References DL_OP_EQUALS, FML_DCHECK, FOR_EACH_DISPLAY_LIST_OP, kEqual, kNotEqual, kUseBulkCompare, and result.

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

882  {
883  // These conditions are checked by the caller...
884  FML_DCHECK((endA - ptrA) == (endB - ptrB));
885  FML_DCHECK(ptrA != ptrB);
886  uint8_t* bulkStartA = ptrA;
887  uint8_t* bulkStartB = ptrB;
888  while (ptrA < endA && ptrB < endB) {
889  auto opA = (const DLOp*)ptrA;
890  auto opB = (const DLOp*)ptrB;
891  if (opA->type != opB->type || opA->size != opB->size) {
892  return false;
893  }
894  ptrA += opA->size;
895  ptrB += opB->size;
896  FML_DCHECK(ptrA <= endA);
897  FML_DCHECK(ptrB <= endB);
899  switch (opA->type) {
900 #define DL_OP_EQUALS(name) \
901  case DisplayListOpType::k##name: \
902  result = static_cast<const name##Op*>(opA)->equals( \
903  static_cast<const name##Op*>(opB)); \
904  break;
905 
907 
908 #undef DL_OP_DISPATCH
909 
910  default:
911  FML_DCHECK(false);
912  return false;
913  }
914  switch (result) {
915  case DisplayListCompare::kNotEqual:
916  return false;
917  case DisplayListCompare::kUseBulkCompare:
918  break;
919  case DisplayListCompare::kEqual:
920  // Check if we have a backlog of bytes to bulk compare and then
921  // reset the bulk compare pointers to the address following this op
922  auto bulkBytes = reinterpret_cast<const uint8_t*>(opA) - bulkStartA;
923  if (bulkBytes > 0) {
924  if (memcmp(bulkStartA, bulkStartB, bulkBytes) != 0) {
925  return false;
926  }
927  }
928  bulkStartA = ptrA;
929  bulkStartB = ptrB;
930  break;
931  }
932  }
933  if (ptrA != endA || ptrB != endB) {
934  return false;
935  }
936  if (bulkStartA < ptrA) {
937  // Perform a final bulk compare if we have remaining bytes waiting
938  if (memcmp(bulkStartA, bulkStartB, ptrA - bulkStartA) != 0) {
939  return false;
940  }
941  }
942  return true;
943 }
#define FML_DCHECK(condition)
Definition: logging.h:86
GAsyncResult * result
#define DL_OP_EQUALS(name)
DisplayListCompare
Definition: display_list.cc:39
#define FOR_EACH_DISPLAY_LIST_OP(V)
Definition: display_list.h:66

◆ ComputePlatformResolvedLocale()

Dart_Handle flutter::ComputePlatformResolvedLocale ( Dart_Handle  supportedLocalesHandle)

Definition at line 467 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().

467  {
468  std::vector<std::string> supportedLocales =
470  supportedLocalesHandle);
471 
472  std::vector<std::string> results =
473  *UIDartState::Current()
474  ->platform_configuration()
475  ->client()
476  ->ComputePlatformResolvedLocale(supportedLocales);
477 
479 }
Dart_Handle ToDart(const T &object)

◆ ConvertMappingToNSData()

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

Definition at line 32 of file buffer_conversions.mm.

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

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

32  {
33  size_t size = buffer.GetSize();
34  return [NSData dataWithBytesNoCopy:buffer.Release() length:size];
35 }
constexpr std::size_t size(T(&array)[N])
Definition: size.h:13
uint8_t * Release()
Definition: mapping.cc:137
size_t GetSize() const override
Definition: mapping.cc:129
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:994

◆ 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:335
double top
Definition: embedder.h:334
double left
Definition: embedder.h:333
double bottom
Definition: embedder.h:336
FlutterPlatformViewMutationType type
The type of the mutation described by the subsequent union.
Definition: embedder.h:994

◆ 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:348
FlutterSize upper_right_corner_radius
Definition: embedder.h:349
double right
Definition: embedder.h:335
FlutterSize lower_right_corner_radius
Definition: embedder.h:350
double top
Definition: embedder.h:334
double left
Definition: embedder.h:333
double bottom
Definition: embedder.h:336
FlutterRoundedRect clip_rounded_rect
Definition: embedder.h:998
FlutterPlatformViewMutationType type
The type of the mutation described by the subsequent union.
Definition: embedder.h:994
FlutterSize lower_left_corner_radius
Definition: embedder.h:351
FlutterRect rect
Definition: embedder.h:347

◆ ConvertMutation() [4/4]

static std::unique_ptr<FlutterPlatformViewMutation> flutter::ConvertMutation ( const SkMatrix &  matrix)
static

Definition at line 87 of file embedder_layers.cc.

References kFlutterPlatformViewMutationTypeTransformation, FlutterTransformation::pers0, FlutterTransformation::pers1, FlutterTransformation::pers2, FlutterTransformation::scaleX, FlutterTransformation::scaleY, FlutterTransformation::skewX, FlutterTransformation::skewY, FlutterPlatformViewMutation::transformation, FlutterTransformation::transX, FlutterTransformation::transY, and FlutterPlatformViewMutation::type.

88  {
89  FlutterPlatformViewMutation mutation = {};
91  mutation.transformation.scaleX = matrix[SkMatrix::kMScaleX];
92  mutation.transformation.skewX = matrix[SkMatrix::kMSkewX];
93  mutation.transformation.transX = matrix[SkMatrix::kMTransX];
94  mutation.transformation.skewY = matrix[SkMatrix::kMSkewY];
95  mutation.transformation.scaleY = matrix[SkMatrix::kMScaleY];
96  mutation.transformation.transY = matrix[SkMatrix::kMTransY];
97  mutation.transformation.pers0 = matrix[SkMatrix::kMPersp0];
98  mutation.transformation.pers1 = matrix[SkMatrix::kMPersp1];
99  mutation.transformation.pers2 = matrix[SkMatrix::kMPersp2];
100  return std::make_unique<FlutterPlatformViewMutation>(mutation);
101 }
double skewY
vertical skew factor
Definition: embedder.h:238
double skewX
horizontal skew factor
Definition: embedder.h:234
double pers1
input y-axis perspective factor
Definition: embedder.h:246
double pers2
perspective scale factor
Definition: embedder.h:248
FlutterTransformation transformation
Definition: embedder.h:999
double pers0
input x-axis perspective factor
Definition: embedder.h:244
double scaleY
vertical scale factor
Definition: embedder.h:240
double transX
horizontal translation
Definition: embedder.h:236
double transY
vertical translation
Definition: embedder.h:242
FlutterPlatformViewMutationType type
The type of the mutation described by the subsequent union.
Definition: embedder.h:994
double scaleX
horizontal scale factor
Definition: embedder.h:232

◆ ConvertNSDataToMappingPtr()

std::unique_ptr< fml::Mapping > flutter::ConvertNSDataToMappingPtr ( NSData *  data)

Definition at line 37 of file buffer_conversions.mm.

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

37  {
38  return std::make_unique<NSDataMapping>(data);
39 }

◆ ConvertToFlutterLocale()

std::vector< FlutterLocale > flutter::ConvertToFlutterLocale ( const std::vector< LanguageInfo > &  languages)

Definition at line 131 of file system_utils.cc.

References FlutterLocale::country_code, FlutterLocale::language_code, FlutterLocale::script_code, FlutterLocale::struct_size, and FlutterLocale::variant_code.

Referenced by SetUpLocales().

132  {
133  std::vector<FlutterLocale> flutter_locales;
134  flutter_locales.reserve(languages.size());
135  for (const auto& info : languages) {
136  FlutterLocale locale = {};
137  locale.struct_size = sizeof(FlutterLocale);
138  locale.language_code = info.language.c_str();
139  if (!info.territory.empty()) {
140  locale.country_code = info.territory.c_str();
141  }
142  if (!info.codeset.empty()) {
143  locale.script_code = info.codeset.c_str();
144  }
145  if (!info.modifier.empty()) {
146  locale.variant_code = info.modifier.c_str();
147  }
148  flutter_locales.push_back(locale);
149  }
150 
151  return flutter_locales;
152 }
size_t struct_size
This size of this struct. Must be sizeof(FlutterLocale).
Definition: embedder.h:1137
const char * variant_code
Definition: embedder.h:1156
const char * script_code
Definition: embedder.h:1151
const char * country_code
Definition: embedder.h:1146
const char * language_code
Definition: embedder.h:1141

◆ ConvertWinButtonToFlutterButton()

static uint64_t flutter::ConvertWinButtonToFlutterButton ( UINT  button)
static

Definition at line 111 of file flutter_window_win32.cc.

References kFlutterPointerButtonMouseBack, kFlutterPointerButtonMouseForward, kFlutterPointerButtonMouseMiddle, kFlutterPointerButtonMousePrimary, and kFlutterPointerButtonMouseSecondary.

Referenced by flutter::FlutterWindowWin32::OnPointerDown(), and flutter::FlutterWindowWin32::OnPointerUp().

111  {
112  switch (button) {
113  case WM_LBUTTONDOWN:
114  case WM_LBUTTONUP:
116  case WM_RBUTTONDOWN:
117  case WM_RBUTTONUP:
119  case WM_MBUTTONDOWN:
120  case WM_MBUTTONUP:
122  case XBUTTON1:
124  case XBUTTON2:
126  }
127  std::cerr << "Mouse button not recognized: " << button << std::endl;
128  return 0;
129 }

◆ CopyMappingPtrToNSData()

NSData * flutter::CopyMappingPtrToNSData ( std::unique_ptr< fml::Mapping mapping)

Definition at line 41 of file buffer_conversions.mm.

References length.

Referenced by flutter::PlatformMessageResponseDarwin::Complete().

41  {
42  return [NSData dataWithBytes:mapping->GetMapping() length:mapping->GetSize()];
43 }
size_t length

◆ CopyNSDataToMapping()

fml::MallocMapping flutter::CopyNSDataToMapping ( NSData *  data)

Definition at line 27 of file buffer_conversions.mm.

References fml::MallocMapping::Copy().

Referenced by FlutterEngine::run.

27  {
28  const uint8_t* bytes = static_cast<const uint8_t*>(data.bytes);
29  return fml::MallocMapping::Copy(bytes, data.length);
30 }
static MallocMapping Copy(const T *begin, const T *end)
Definition: mapping.h:147

◆ CopyToBitmap()

static bool flutter::CopyToBitmap ( SkBitmap *  dst,
SkColorType  dstColorType,
const SkBitmap &  src 
)
static

Definition at line 47 of file multi_frame_codec.cc.

References callback, flutter::CanvasImage::Create(), flutter::ImageGenerator::FrameInfo::disposal_method, flutter::ImageGenerator::FrameInfo::duration, FML_DLOG, FML_LOG, fml::WeakPtr< T >::get(), InvokeNextFrameCallback(), fml::MakeCopyable(), fml::TaskRunner::PostTask(), and flutter::ImageGenerator::FrameInfo::required_frame.

49  {
50  SkPixmap srcPM;
51  if (!src.peekPixels(&srcPM)) {
52  return false;
53  }
54 
55  SkBitmap tmpDst;
56  SkImageInfo dstInfo = srcPM.info().makeColorType(dstColorType);
57  if (!tmpDst.setInfo(dstInfo)) {
58  return false;
59  }
60 
61  if (!tmpDst.tryAllocPixels()) {
62  return false;
63  }
64 
65  SkPixmap dstPM;
66  if (!tmpDst.peekPixels(&dstPM)) {
67  return false;
68  }
69 
70  if (!srcPM.readPixels(dstPM)) {
71  return false;
72  }
73 
74  dst->swap(tmpDst);
75  return true;
76 }

◆ CopyV() [1/2]

static void flutter::CopyV ( void *  dst)
static

◆ CopyV() [2/2]

template<typename S , typename... Rest>
static void flutter::CopyV ( void *  dst,
const S *  src,
int  n,
Rest &&...  rest 
)
static

Definition at line 985 of file display_list.cc.

References args, CopyV(), DL_BUILDER_PAGE, FML_DCHECK, and fml::size().

985  {
986  FML_DCHECK(((uintptr_t)dst & (alignof(S) - 1)) == 0)
987  << "Expected " << dst << " to be aligned for at least " << alignof(S)
988  << " bytes.";
989  sk_careful_memcpy(dst, src, n * sizeof(S));
990  CopyV(SkTAddOffset<void>(dst, n * sizeof(S)), std::forward<Rest>(rest)...);
991 }
#define FML_DCHECK(condition)
Definition: logging.h:86
static void CopyV(void *dst, const S *src, int n, Rest &&... rest)

◆ CreateAndroidContext()

static std::shared_ptr<flutter::AndroidContext> flutter::CreateAndroidContext ( bool  use_software_rendering,
bool  create_onscreen_surface 
)
static

Definition at line 57 of file platform_view_android.cc.

References kOpenGLES, kSoftware, and kVulkan.

59  {
60  if (!create_onscreen_surface) {
61  return nullptr;
62  }
63  if (use_software_rendering) {
64  return std::make_shared<AndroidContext>(AndroidRenderingAPI::kSoftware);
65  }
66 #if SHELL_ENABLE_VULKAN
67  return std::make_shared<AndroidContext>(AndroidRenderingAPI::kVulkan);
68 #else // SHELL_ENABLE_VULKAN
69  return std::make_unique<AndroidContextGL>(
70  AndroidRenderingAPI::kOpenGLES,
71  fml::MakeRefCounted<AndroidEnvironmentGL>());
72 #endif // SHELL_ENABLE_VULKAN
73 }

◆ CreateContext()

static EGLResult<EGLContext> flutter::CreateContext ( EGLDisplay  display,
EGLConfig  config,
EGLContext  share = EGL_NO_CONTEXT 
)
static

Definition at line 62 of file android_context_gl.cc.

Referenced by flutter::AndroidContextGL::AndroidContextGL(), and flutter::AndroidContextGL::CreateNewContext().

64  {
65  EGLint attributes[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
66 
67  EGLContext context = eglCreateContext(display, config, share, attributes);
68 
69  return {context != EGL_NO_CONTEXT, context};
70 }

◆ CreateEmbedderTaskRunner()

static std::pair<bool, fml::RefPtr<EmbedderTaskRunner> > flutter::CreateEmbedderTaskRunner ( const FlutterTaskRunnerDescription description)
static

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.

Parameters
[in]descriptionThe description
Returns
A pair that returns if the embedder has specified a task runner (null otherwise) and whether to terminate further engine launch.

Definition at line 30 of file embedder_thread_host.cc.

References FML_LOG, FlutterTaskRunnerDescription::post_task_callback, FlutterTaskRunnerDescription::runs_task_on_current_thread_callback, SAFE_ACCESS, and user_data.

30  {
31  if (description == nullptr) {
32  // This is not embedder error. The embedder API will just have to create a
33  // plain old task runner (and create a thread for it) instead of using a
34  // task runner provided to us by the embedder.
35  return {true, {}};
36  }
37 
38  if (SAFE_ACCESS(description, runs_task_on_current_thread_callback, nullptr) ==
39  nullptr) {
40  FML_LOG(ERROR) << "FlutterTaskRunnerDescription.runs_task_on_current_"
41  "thread_callback was nullptr.";
42  return {false, {}};
43  }
44 
45  if (SAFE_ACCESS(description, post_task_callback, nullptr) == nullptr) {
46  FML_LOG(ERROR)
47  << "FlutterTaskRunnerDescription.post_task_callback was nullptr.";
48  return {false, {}};
49  }
50 
51  auto user_data = SAFE_ACCESS(description, user_data, nullptr);
52 
53  // ABI safety checks have been completed.
54  auto post_task_callback_c = description->post_task_callback;
55  auto runs_task_on_current_thread_callback_c =
57 
58  EmbedderTaskRunner::DispatchTable task_runner_dispatch_table = {
59  // .post_task_callback
60  [post_task_callback_c, user_data](EmbedderTaskRunner* task_runner,
61  uint64_t task_baton,
62  fml::TimePoint target_time) -> void {
63  FlutterTask task = {
64  // runner
65  reinterpret_cast<FlutterTaskRunner>(task_runner),
66  // task
67  task_baton,
68  };
69  post_task_callback_c(task, target_time.ToEpochDelta().ToNanoseconds(),
70  user_data);
71  },
72  // runs_task_on_current_thread_callback
73  [runs_task_on_current_thread_callback_c, user_data]() -> bool {
74  return runs_task_on_current_thread_callback_c(user_data);
75  }};
76 
77  return {true, fml::MakeRefCounted<EmbedderTaskRunner>(
78  task_runner_dispatch_table,
79  SAFE_ACCESS(description, identifier, 0u))};
80 }
void * user_data
#define FML_LOG(severity)
Definition: logging.h:65
#define SAFE_ACCESS(pointer, member, default_value)
FlutterTaskRunnerPostTaskCallback post_task_callback
Definition: embedder.h:915
BoolCallback runs_task_on_current_thread_callback
Definition: embedder.h:904

◆ CreateFinishedBuildRecorder()

static std::unique_ptr<FrameTimingsRecorder> flutter::CreateFinishedBuildRecorder ( )
static

Definition at line 82 of file rasterizer_unittests.cc.

References fml::TimePoint::Now().

Referenced by TEST().

82  {
83  std::unique_ptr<FrameTimingsRecorder> recorder =
84  std::make_unique<FrameTimingsRecorder>();
85  const auto now = fml::TimePoint::Now();
86  recorder->RecordVsync(now, now);
87  recorder->RecordBuildStart(now);
88  recorder->RecordBuildEnd(now);
89  return recorder;
90 }
static TimePoint Now()
Definition: time_point.cc:38

◆ CreateFlutterCallbackInformation()

jobject flutter::CreateFlutterCallbackInformation ( JNIEnv *  env,
const std::string &  callbackName,
const std::string &  callbackClassName,
const std::string &  callbackLibraryPath 
)

Definition at line 52 of file platform_view_android_jni_impl.cc.

References g_flutter_callback_info_constructor, and fml::jni::JavaRef< T >::obj().

Referenced by LookupCallbackInformation().

56  {
57  return env->NewObject(g_flutter_callback_info_class->obj(),
59  env->NewStringUTF(callbackName.c_str()),
60  env->NewStringUTF(callbackClassName.c_str()),
61  env->NewStringUTF(callbackLibraryPath.c_str()));
62 }
static jmethodID g_flutter_callback_info_constructor
static fml::jni::ScopedJavaGlobalRef< jclass > * g_flutter_callback_info_class

◆ CreateFlutterViewID()

static std::string flutter::CreateFlutterViewID ( intptr_t  handler)
static

Definition at line 226 of file service_protocol.cc.

Referenced by flutter::ServiceProtocol::Handler::Description::Write().

226  {
227  std::stringstream stream;
228  stream << kViewIdPrefx << "0x" << std::hex << handler;
229  return stream.str();
230 }
static constexpr std::string_view kViewIdPrefx

◆ CreateGLInterface()

static sk_sp<const GrGLInterface> flutter::CreateGLInterface ( GPUSurfaceGLDelegate::GLProcResolver  proc_resolver)
static

Definition at line 57 of file gpu_surface_gl_delegate.cc.

References FML_LOG, and IsProcResolverOpenGLES().

Referenced by flutter::GPUSurfaceGLDelegate::GetDefaultPlatformGLInterface(), and flutter::GPUSurfaceGLDelegate::GetGLInterface().

58  {
59  if (proc_resolver == nullptr) {
60  // If there is no custom proc resolver, ask Skia to guess the native
61  // interface. This often leads to interesting results on most platforms.
62  return GrGLMakeNativeInterface();
63  }
64 
65  struct ProcResolverContext {
66  GPUSurfaceGLDelegate::GLProcResolver resolver;
67  };
68 
69  ProcResolverContext context = {proc_resolver};
70 
71  GrGLGetProc gl_get_proc = [](void* context,
72  const char gl_proc_name[]) -> GrGLFuncPtr {
73  auto proc_resolver_context =
74  reinterpret_cast<ProcResolverContext*>(context);
75  return reinterpret_cast<GrGLFuncPtr>(
76  proc_resolver_context->resolver(gl_proc_name));
77  };
78 
79  // glGetString indicates an OpenGL ES interface.
80  if (IsProcResolverOpenGLES(proc_resolver)) {
81  return GrGLMakeAssembledGLESInterface(&context, gl_get_proc);
82  }
83 
84  // Fallback to OpenGL.
85  if (auto interface = GrGLMakeAssembledGLInterface(&context, gl_get_proc)) {
86  return interface;
87  }
88 
89  FML_LOG(ERROR) << "Could not create a valid GL interface.";
90  return nullptr;
91 }
static bool IsProcResolverOpenGLES(GPUSurfaceGLDelegate::GLProcResolver proc_resolver)
#define FML_LOG(severity)
Definition: logging.h:65

◆ CreateIsolateID()

static std::string flutter::CreateIsolateID ( int64_t  isolate)
static

Definition at line 232 of file service_protocol.cc.

Referenced by flutter::ServiceProtocol::Handler::Description::Write().

232  {
233  std::stringstream stream;
234  stream << "isolates/" << isolate;
235  return stream.str();
236 }

◆ CreateObject()

static SemanticsObject* flutter::CreateObject ( const flutter::SemanticsNode node,
fml::WeakPtr< AccessibilityBridge weak_ptr 
)
static

Definition at line 257 of file accessibility_bridge.mm.

References flutter::SemanticsNode::HasFlag(), flutter::SemanticsNode::id, kHasCheckedState, kHasImplicitScrolling, kHasToggledState, kIsReadOnly, and kIsTextField.

Referenced by DidFlagChange().

258  {
261  // Text fields are backed by objects that implement UITextInput.
262  return [[[TextInputSemanticsObject alloc] initWithBridge:weak_ptr uid:node.id] autorelease];
265  return [[[FlutterSwitchSemanticsObject alloc] initWithBridge:weak_ptr uid:node.id] autorelease];
267  SemanticsObject* delegateObject =
268  [[[FlutterSemanticsObject alloc] initWithBridge:weak_ptr uid:node.id] autorelease];
270  initWithSemanticsObject:delegateObject] autorelease];
271  } else {
272  return [[[FlutterSemanticsObject alloc] initWithBridge:weak_ptr uid:node.id] autorelease];
273  }
274 }
bool HasFlag(SemanticsFlags flag) const

◆ CreateSnapshotSurface()

static sk_sp<SkSurface> flutter::CreateSnapshotSurface ( GrDirectContext *  surface_context,
const SkISize &  size 
)
static

Definition at line 578 of file rasterizer.cc.

References flutter::CompositorContext::AcquireFrame(), flutter::Rasterizer::compositor_context(), FML_LOG, and flutter::LayerTree::frame_size().

579  {
580  const auto image_info = SkImageInfo::MakeN32Premul(
581  size.width(), size.height(), SkColorSpace::MakeSRGB());
582  if (surface_context) {
583  // There is a rendering surface that may contain textures that are going to
584  // be referenced in the layer tree about to be drawn.
585  return SkSurface::MakeRenderTarget(surface_context, //
586  SkBudgeted::kNo, //
587  image_info //
588  );
589  }
590 
591  // There is no rendering surface, assume no GPU textures are present and
592  // create a raster surface.
593  return SkSurface::MakeRaster(image_info);
594 }
constexpr std::size_t size(T(&array)[N])
Definition: size.h:13

◆ DartFileModifiedCallback()

bool flutter::DartFileModifiedCallback ( const char *  source_url,
int64_t  since_ms 
)

Definition at line 130 of file dart_vm.cc.

References fml::TimeDelta::FromMilliseconds(), fml::TimeDelta::FromSeconds(), kFileUriPrefixLength, and path.

Referenced by flutter::DartVM::GetVMLaunchCount().

130  {
131  if (strncmp(source_url, kFileUriPrefix, kFileUriPrefixLength) != 0u) {
132  // Assume modified.
133  return true;
134  }
135 
136  const char* path = source_url + kFileUriPrefixLength;
137  struct stat info;
138  if (stat(path, &info) < 0) {
139  return true;
140  }
141 
142  // If st_mtime is zero, it's more likely that the file system doesn't support
143  // mtime than that the file was actually modified in the 1970s.
144  if (!info.st_mtime) {
145  return true;
146  }
147 
148  // It's very unclear what time bases we're with here. The Dart API doesn't
149  // document the time base for since_ms. Reading the code, the value varies by
150  // platform, with a typical source being something like gettimeofday.
151  //
152  // We add one to st_mtime because st_mtime has less precision than since_ms
153  // and we want to treat the file as modified if the since time is between
154  // ticks of the mtime.
155  fml::TimeDelta mtime = fml::TimeDelta::FromSeconds(info.st_mtime + 1);
157 
158  return mtime > since;
159 }
DEF_SWITCHES_START snapshot asset path
Definition: switches.h:32
static constexpr TimeDelta FromSeconds(int64_t seconds)
Definition: time_delta.h:49
constexpr char kFileUriPrefix[]
Definition: dart_vm.cc:127
constexpr size_t kFileUriPrefixLength
Definition: dart_vm.cc:128
static constexpr TimeDelta FromMilliseconds(int64_t millis)
Definition: time_delta.h:46

◆ DartOldGenHeapSizeArgs()

static std::string flutter::DartOldGenHeapSizeArgs ( uint64_t  heap_size)
static

Definition at line 121 of file dart_vm.cc.

Referenced by flutter::DartVM::GetVMLaunchCount().

121  {
122  std::ostringstream oss;
123  oss << "--old_gen_heap_size=" << heap_size;
124  return oss.str();
125 }

◆ decodeFontFeatures()

void flutter::decodeFontFeatures ( Dart_Handle  font_features_data,
txt::FontFeatures font_features 
)

Definition at line 350 of file paragraph_builder.cc.

References tonic::DartByteData::data(), FML_CHECK, tonic::DartByteData::length_in_bytes(), txt::FontFeatures::SetFeature(), and value.

Referenced by flutter::ParagraphBuilder::pushStyle().

351  { // NOLINT
352  tonic::DartByteData byte_data(font_features_data);
353  FML_CHECK(byte_data.length_in_bytes() % kBytesPerFontFeature == 0);
354 
355  size_t feature_count = byte_data.length_in_bytes() / kBytesPerFontFeature;
356  for (size_t feature_index = 0; feature_index < feature_count;
357  ++feature_index) {
358  size_t feature_offset = feature_index * kBytesPerFontFeature;
359  const char* feature_bytes =
360  static_cast<const char*>(byte_data.data()) + feature_offset;
361  std::string tag(feature_bytes, kFontFeatureTagLength);
362  int32_t value = *(reinterpret_cast<const int32_t*>(feature_bytes +
363  kFontFeatureTagLength));
364  font_features.SetFeature(tag, value);
365  }
366 }
uint8_t value
void SetFeature(std::string tag, int value)
#define FML_CHECK(condition)
Definition: logging.h:68

◆ decodeStrut()

void flutter::decodeStrut ( Dart_Handle  strut_data,
const std::vector< std::string > &  strut_font_families,
txt::ParagraphStyle paragraph_style 
)

Definition at line 176 of file paragraph_builder.cc.

References flutter::PlatformConfiguration::client(), txt::ParagraphBuilder::CreateTxtBuilder(), flutter::UIDartState::Current(), tonic::DartByteData::data(), txt::ParagraphStyle::ellipsis, flutter::UIDartState::enable_skparagraph(), txt::ParagraphStyle::font_family, txt::ParagraphStyle::font_size, txt::ParagraphStyle::font_style, txt::ParagraphStyle::font_weight, txt::ParagraphStyle::force_strut_height, flutter::FontCollection::GetFontCollection(), flutter::PlatformConfigurationClient::GetFontCollection(), txt::ParagraphStyle::has_height_override, height, txt::ParagraphStyle::height, tonic::DartByteData::length_in_bytes(), txt::ParagraphStyle::locale, txt::ParagraphStyle::max_lines, flutter::UIDartState::platform_configuration(), txt::ParagraphStyle::strut_enabled, txt::ParagraphStyle::strut_font_families, txt::ParagraphStyle::strut_font_size, txt::ParagraphStyle::strut_font_style, txt::ParagraphStyle::strut_font_weight, txt::ParagraphStyle::strut_half_leading, txt::ParagraphStyle::strut_has_height_override, txt::ParagraphStyle::strut_height, txt::ParagraphStyle::strut_leading, txt::ParagraphStyle::text_align, txt::ParagraphStyle::text_direction, txt::ParagraphStyle::text_height_behavior, and flutter::ParagraphBuilder::~ParagraphBuilder().

178  { // NOLINT
179  if (strut_data == Dart_Null()) {
180  return;
181  }
182 
183  tonic::DartByteData byte_data(strut_data);
184  if (byte_data.length_in_bytes() == 0) {
185  return;
186  }
187  paragraph_style.strut_enabled = true;
188 
189  const uint8_t* uint8_data = static_cast<const uint8_t*>(byte_data.data());
190  uint8_t mask = uint8_data[0];
191 
192  // Data is stored in order of increasing size, eg, 8 bit ints will be before
193  // any 32 bit ints. In addition, the order of decoding is the same order
194  // as it is encoded, and the order is used to maintain consistency.
195  size_t byte_count = 1;
196  if (mask & sFontWeightMask) {
197  paragraph_style.strut_font_weight =
198  static_cast<txt::FontWeight>(uint8_data[byte_count++]);
199  }
200  if (mask & sFontStyleMask) {
201  paragraph_style.strut_font_style =
202  static_cast<txt::FontStyle>(uint8_data[byte_count++]);
203  }
204 
205  paragraph_style.strut_half_leading = mask & sLeadingDistributionMask;
206 
207  std::vector<float> float_data;
208  float_data.resize((byte_data.length_in_bytes() - byte_count) / 4);
209  memcpy(float_data.data(),
210  static_cast<const char*>(byte_data.data()) + byte_count,
211  byte_data.length_in_bytes() - byte_count);
212  size_t float_count = 0;
213  if (mask & sFontSizeMask) {
214  paragraph_style.strut_font_size = float_data[float_count++];
215  }
216  if (mask & sHeightMask) {
217  paragraph_style.strut_height = float_data[float_count++];
218  paragraph_style.strut_has_height_override = true;
219  }
220  if (mask & sLeadingMask) {
221  paragraph_style.strut_leading = float_data[float_count++];
222  }
223 
224  // The boolean is stored as the last bit in the bitmask, as null
225  // and false have the same behavior.
226  paragraph_style.force_strut_height = mask & sForceStrutHeightMask;
227 
228  if (mask & sFontFamilyMask) {
229  paragraph_style.strut_font_families = strut_font_families;
230  } else {
231  // Provide an empty font name so that the platform default font will be
232  // used.
233  paragraph_style.strut_font_families.push_back("");
234  }
235 }
FontStyle
Definition: font_style.h:22
std::vector< std::string > strut_font_families
FontWeight strut_font_weight
FontWeight
Definition: font_weight.h:22
FontStyle strut_font_style

◆ decodeTextShadows()

void flutter::decodeTextShadows ( Dart_Handle  shadows_data,
std::vector< txt::TextShadow > &  decoded_shadows 
)

Definition at line 325 of file paragraph_builder.cc.

References tonic::DartByteData::data(), FML_CHECK, kColorDefault, and tonic::DartByteData::length_in_bytes().

Referenced by flutter::ParagraphBuilder::pushStyle().

327  { // NOLINT
328  decoded_shadows.clear();
329 
330  tonic::DartByteData byte_data(shadows_data);
331  FML_CHECK(byte_data.length_in_bytes() % kBytesPerShadow == 0);
332 
333  const uint32_t* uint_data = static_cast<const uint32_t*>(byte_data.data());
334  const float* float_data = static_cast<const float*>(byte_data.data());
335 
336  size_t shadow_count = byte_data.length_in_bytes() / kBytesPerShadow;
337  size_t shadow_count_offset = 0;
338  for (size_t shadow_index = 0; shadow_index < shadow_count; ++shadow_index) {
339  shadow_count_offset = shadow_index * kShadowPropertiesCount;
340  SkColor color =
341  uint_data[shadow_count_offset + kColorOffset] ^ kColorDefault;
342  decoded_shadows.emplace_back(
343  color,
344  SkPoint::Make(float_data[shadow_count_offset + kXOffset],
345  float_data[shadow_count_offset + kYOffset]),
346  float_data[shadow_count_offset + kBlurOffset]);
347  }
348 }
constexpr uint32_t kColorDefault
Definition: paint.cc:45
#define FML_CHECK(condition)
Definition: logging.h:68

◆ DEF_SWITCH() [1/9]

DEF_SWITCHES_START flutter::DEF_SWITCH ( AotSharedLibraryName  ,
"aot-shared-library-name ,
"Name of the *.so containing AOT compiled Dart assets."   
)

◆ DEF_SWITCH() [2/9]

DEF_SWITCHES_START snapshot asset Path to the directory containing the four files specified by VmSnapshotInstructions and IsolateSnapshotInstructions flutter::DEF_SWITCH ( VmSnapshotData  ,
"vm-snapshot-data"  ,
"The VM snapshot data that will be memory mapped as read-only. " "SnapshotAssetPath must be present."   
)

◆ DEF_SWITCH() [3/9]

DEF_SWITCHES_START snapshot asset Path to the directory containing the four files specified by VmSnapshotInstructions and IsolateSnapshotInstructions vm snapshot The VM instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present flutter::DEF_SWITCH ( IsolateSnapshotData  ,
"isolate-snapshot-data"  ,
"The isolate snapshot data that will be memory mapped as read-only. " "SnapshotAssetPath must be present."   
)

◆ DEF_SWITCH() [4/9]

DEF_SWITCHES_START snapshot asset Path to the directory containing the four files specified by VmSnapshotInstructions and IsolateSnapshotInstructions vm snapshot The VM instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present isolate snapshot The isolate instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present flutter::DEF_SWITCH ( CacheDirPath  ,
"cache-dir-path ,
"Path to the cache directory. " "This is different from the persistent_cache_path in embedder.  h,
" "which is used for Skia shader cache."   
)

◆ DEF_SWITCH() [5/9]

DEF_SWITCHES_START snapshot asset Path to the directory containing the four files specified by VmSnapshotInstructions and IsolateSnapshotInstructions vm snapshot The VM instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present isolate snapshot The isolate instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present icu symbol Prefix for the symbols representing ICU data linked into the Flutter library flutter::DEF_SWITCH ( ICUNativeLibPath  ,
"icu-native-lib-path ,
"Path to the library file that exports the ICU data."   
)

◆ DEF_SWITCH() [6/9]

DEF_SWITCHES_START snapshot asset Path to the directory containing the four files specified by VmSnapshotInstructions and IsolateSnapshotInstructions vm snapshot The VM instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present isolate snapshot The isolate instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present icu symbol Prefix for the symbols representing ICU data linked into the Flutter library dart Flags passed directly to the Dart VM without being interpreted by the Flutter shell flutter::DEF_SWITCH ( DeviceObservatoryHost  ,
"observatory-host"  ,
"The hostname/IP address on which the Dart Observatory should " "be served. If not  set,
defaults to 127.0.0.1 or ::1 depending on " "whether --ipv6 is specified."   
)

◆ DEF_SWITCH() [7/9]

DEF_SWITCHES_START snapshot asset Path to the directory containing the four files specified by VmSnapshotInstructions and IsolateSnapshotInstructions vm snapshot The VM instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present isolate snapshot The isolate instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present icu symbol Prefix for the symbols representing ICU data linked into the Flutter library dart Flags passed directly to the Dart VM without being interpreted by the Flutter shell observatory A custom Dart Observatory port The default is to pick a randomly available open port flutter::DEF_SWITCH ( DisableObservatory  ,
"disable-observatory"  ,
"Disable the Dart Observatory. The observatory is never available " "in release mode."   
)

◆ DEF_SWITCH() [8/9]

DEF_SWITCHES_START snapshot asset Path to the directory containing the four files specified by VmSnapshotInstructions and IsolateSnapshotInstructions vm snapshot The VM instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present isolate snapshot The isolate instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present icu symbol Prefix for the symbols representing ICU data linked into the Flutter library dart Flags passed directly to the Dart VM without being interpreted by the Flutter shell observatory A custom Dart Observatory port The default is to pick a randomly available open port disable observatory Disable mDNS Dart Observatory publication flutter::DEF_SWITCH ( IPv6  ,
"ipv6"  ,
"Bind to the IPv6 localhost address for the Dart Observatory. " "Ignored if --observatory-host is set."   
)

◆ DEF_SWITCH() [9/9]

DEF_SWITCHES_START snapshot asset Path to the directory containing the four files specified by VmSnapshotInstructions and IsolateSnapshotInstructions vm snapshot The VM instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present isolate snapshot The isolate instructions snapshot that will be memory mapped as read and executable SnapshotAssetPath must be present icu symbol Prefix for the symbols representing ICU data linked into the Flutter library dart Flags passed directly to the Dart VM without being interpreted by the Flutter shell observatory A custom Dart Observatory port The default is to pick a randomly available open port disable observatory Disable mDNS Dart Observatory publication enable dart Enable Dart profiling Profiling information can be viewed from the observatory flutter::DEF_SWITCH ( EndlessTraceBuffer  ,
"endless-trace-buffer"  ,
"Enable an endless trace buffer. The default is a ring buffer. " "This is useful when very old events need to viewed. For  example,
" "during application launch. Memory usage will continue to grow " "indefinitely however."   
)

◆ DeferredComponentInstallFailure()

static void flutter::DeferredComponentInstallFailure ( JNIEnv *  env,
jobject  obj,
jint  jLoadingUnitId,
jstring  jError,
jboolean  jTransient 
)
static

Definition at line 540 of file platform_view_android_jni_impl.cc.

References fml::jni::JavaStringToString(), and LoadLoadingUnitFailure().

Referenced by RegisterApi().

544  {
545  LoadLoadingUnitFailure(static_cast<intptr_t>(jLoadingUnitId),
546  fml::jni::JavaStringToString(env, jError),
547  static_cast<bool>(jTransient));
548 }
static void LoadLoadingUnitFailure(intptr_t loading_unit_id, std::string message, bool transient)
std::string JavaStringToString(JNIEnv *env, jstring str)
Definition: jni_util.cc:76

◆ DEFINE_DRAW_POINTS_OP() [1/3]

flutter::DEFINE_DRAW_POINTS_OP ( Points  ,
kPoints_PointMode   
)

◆ DEFINE_DRAW_POINTS_OP() [2/3]

flutter::DEFINE_DRAW_POINTS_OP ( Lines  ,
kLines_PointMode   
)

◆ DEFINE_DRAW_POINTS_OP() [3/3]

flutter::DEFINE_DRAW_POINTS_OP ( Polygon  ,
kPolygon_PointMode   
)

◆ DeserializeImageWithoutData()

sk_sp< SkImage > flutter::DeserializeImageWithoutData ( const void *  data,
size_t  length,
void *  ctx 
)

Definition at line 56 of file serialization_callbacks.cc.

References FML_CHECK.

Referenced by flutter_runner::Engine::WriteProfileToTrace().

58  {
59  FML_CHECK(length >= sizeof(ImageMetaData));
60  auto metadata = static_cast<const ImageMetaData*>(data);
61  sk_sp<SkColorSpace> color_space = nullptr;
62  if (metadata->has_color_space) {
63  color_space = SkColorSpace::Deserialize(
64  static_cast<const uint8_t*>(data) + sizeof(ImageMetaData),
65  length - sizeof(ImageMetaData));
66  }
67 
68  auto image_size = SkISize::Make(metadata->width, metadata->height);
69  auto info = SkImageInfo::Make(
70  image_size, static_cast<SkColorType>(metadata->color_type),
71  static_cast<SkAlphaType>(metadata->alpha_type), color_space);
72  sk_sp<SkData> image_data =
73  SkData::MakeUninitialized(image_size.width() * image_size.height() * 4);
74  memset(image_data->writable_data(), 0x0f, image_data->size());
75  sk_sp<SkImage> image =
76  SkImage::MakeRasterData(info, image_data, image_size.width() * 4);
77 
78  return image;
79 };
size_t length
#define FML_CHECK(condition)
Definition: logging.h:68

◆ DeserializeTypefaceWithoutData()

sk_sp< SkTypeface > flutter::DeserializeTypefaceWithoutData ( const void *  data,
size_t  length,
void *  ctx 
)

Definition at line 22 of file serialization_callbacks.cc.

Referenced by flutter_runner::Engine::WriteProfileToTrace().

24  {
25  return SkTypeface::MakeDefault();
26 }

◆ DestroyJNI()

static void flutter::DestroyJNI ( JNIEnv *  env,
jobject  jcaller,
jlong  shell_holder 
)
static

Definition at line 137 of file platform_view_android_jni_impl.cc.

References ANDROID_SHELL_HOLDER.

Referenced by RegisterApi().

137  {
138  delete ANDROID_SHELL_HOLDER;
139 }
#define ANDROID_SHELL_HOLDER

◆ DidFlagChange()