#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>

Classes
struct	FlutterSemanticsFlags

struct	FlutterTransformation

struct	FlutterOpenGLTexture

struct	FlutterOpenGLFramebuffer

struct	FlutterOpenGLSurface

struct	FlutterSize
	A structure to represent the width and height. More...

struct	FlutterUIntSize

struct	FlutterRect
	A structure to represent a rectangle. More...

struct	FlutterPoint
	A structure to represent a 2D point. More...

struct	FlutterRoundedRect
	A structure to represent a rounded rectangle. More...

struct	FlutterDamage
	A structure to represent a damage region. More...

struct	FlutterFrameInfo

struct	FlutterPresentInfo

struct	FlutterOpenGLRendererConfig

struct	FlutterMetalExternalTexture

struct	FlutterMetalTexture

struct	FlutterMetalRendererConfig

struct	FlutterVulkanImage

struct	FlutterVulkanRendererConfig

struct	FlutterSoftwareRendererConfig

struct	FlutterRendererConfig

struct	FlutterWindowMetricsEvent

struct	FlutterAddViewResult

struct	FlutterAddViewInfo

struct	FlutterRemoveViewResult

struct	FlutterRemoveViewInfo

struct	FlutterViewFocusEvent

struct	FlutterViewFocusChangeRequest

struct	FlutterPointerEvent

struct	FlutterKeyEvent

struct	FlutterPlatformMessage

struct	FlutterSpellOutStringAttribute

struct	FlutterLocaleStringAttribute

struct	FlutterStringAttribute

struct	FlutterSemanticsNode

struct	FlutterSemanticsNode2

struct	FlutterSemanticsCustomAction

struct	FlutterSemanticsCustomAction2

struct	FlutterSemanticsUpdate

struct	FlutterSemanticsUpdate2
	A batch of updates to semantics nodes and custom actions. More...

struct	FlutterChannelUpdate
	An update to whether a message channel has a listener set or not. More...

struct	FlutterTask

struct	FlutterTaskRunnerDescription

struct	FlutterCustomTaskRunners

struct	FlutterOpenGLBackingStore

struct	FlutterSoftwareBackingStore

struct	FlutterSoftwareBackingStore2

struct	FlutterMetalBackingStore

struct	FlutterVulkanBackingStore

struct	FlutterPlatformViewMutation

struct	FlutterPlatformView

struct	FlutterBackingStore

struct	FlutterBackingStoreConfig

struct	FlutterRegion
	A region represented by a collection of non-overlapping rectangles. More...

struct	FlutterBackingStorePresentInfo

struct	FlutterLayer

struct	FlutterPresentViewInfo

struct	FlutterCompositor

struct	FlutterLocale

struct	FlutterEngineDisplay

struct	FlutterEngineDartBuffer

struct	FlutterEngineDartObject

struct	FlutterEngineAOTDataSource

struct	FlutterProjectArgs

struct	FlutterSendSemanticsActionInfo

struct	FlutterEngineProcTable
	Function-pointer-based versions of the APIs above. More...

Macros
#define	FLUTTER_EXPORT

#define	FLUTTER_API_SYMBOL(symbol) symbol

#define	FLUTTER_ENGINE_VERSION 1

Typedefs
typedef struct _FlutterEngine *	FLUTTER_API_SYMBOL(FlutterEngine)

typedef int64_t	FlutterViewId

typedef void(*	VoidCallback) (void *)

typedef bool(*	FlutterOpenGLSurfaceCallback) (void , bool )

typedef bool(*	BoolCallback) (void *)

typedef FlutterTransformation(*	TransformationCallback) (void *)

typedef uint32_t(*	UIntCallback) (void *)

typedef bool(*	SoftwareSurfacePresentCallback) (void , const void , size_t, size_t)

typedef void (	ProcResolver) (void , const char )

typedef bool(*	TextureFrameCallback) (void , int64_t, size_t, size_t, FlutterOpenGLTexture )

typedef void(*	VsyncCallback) (void *, intptr_t)

typedef void(*	OnPreEngineRestartCallback) (void *)

typedef uint32_t(*	UIntFrameInfoCallback) (void , const FlutterFrameInfo )
	Callback for when a frame buffer object is requested.

typedef void(*	FlutterFrameBufferWithDamageCallback) (void , const intptr_t, FlutterDamage )

typedef bool(*	BoolPresentInfoCallback) (void , const FlutterPresentInfo )
	Callback for when a surface is presented.

typedef const void *	FlutterMetalDeviceHandle
	Alias for id<MTLDevice>.

typedef const void *	FlutterMetalCommandQueueHandle
	Alias for id<MTLCommandQueue>.

typedef const void *	FlutterMetalTextureHandle
	Alias for id<MTLTexture>.

typedef bool(*	FlutterMetalTextureFrameCallback) (void , int64_t, size_t, size_t, FlutterMetalExternalTexture )

typedef FlutterMetalTexture(*	FlutterMetalTextureCallback) (void , const FlutterFrameInfo )
	Callback for when a metal texture is requested.

typedef bool(*	FlutterMetalPresentCallback) (void , const FlutterMetalTexture )

typedef void *	FlutterVulkanInstanceHandle
	Alias for VkInstance.

typedef void *	FlutterVulkanPhysicalDeviceHandle
	Alias for VkPhysicalDevice.

typedef void *	FlutterVulkanDeviceHandle
	Alias for VkDevice.

typedef void *	FlutterVulkanQueueHandle
	Alias for VkQueue.

typedef uint64_t	FlutterVulkanImageHandle
	Alias for VkImage.

typedef void (	FlutterVulkanInstanceProcAddressCallback) (void , FlutterVulkanInstanceHandle, const char )

typedef FlutterVulkanImage(*	FlutterVulkanImageCallback) (void , const FlutterFrameInfo )
	Callback for when a VkImage is requested.

typedef bool(*	FlutterVulkanPresentCallback) (void , const FlutterVulkanImage )

typedef uint64_t	FlutterEngineDisplayId

typedef void(*	FlutterAddViewCallback) (const FlutterAddViewResult *result)

typedef void(*	FlutterRemoveViewCallback) (const FlutterRemoveViewResult *)

typedef void(*	FlutterKeyEventCallback) (bool, void *)

typedef struct _FlutterPlatformMessageResponseHandle	FlutterPlatformMessageResponseHandle

typedef void(*	FlutterPlatformMessageCallback) (const FlutterPlatformMessage , void )

typedef void(*	FlutterDataCallback) (const uint8_t , size_t, void )

typedef int64_t	FlutterPlatformViewIdentifier

typedef void(*	FlutterUpdateSemanticsNodeCallback) (const FlutterSemanticsNode , void )

typedef void(*	FlutterUpdateSemanticsCustomActionCallback) (const FlutterSemanticsCustomAction , void )

typedef void(*	FlutterUpdateSemanticsCallback) (const FlutterSemanticsUpdate , void )

typedef void(*	FlutterUpdateSemanticsCallback2) (const FlutterSemanticsUpdate2 , void )

typedef void(*	FlutterChannelUpdateCallback) (const FlutterChannelUpdate , void )

typedef void(*	FlutterViewFocusChangeRequestCallback) (const FlutterViewFocusChangeRequest , void )

typedef struct _FlutterTaskRunner *	FlutterTaskRunner

typedef void(*	FlutterTaskRunnerPostTaskCallback) (FlutterTask, uint64_t, void *)

typedef bool(*	FlutterBackingStoreCreateCallback) (const FlutterBackingStoreConfig config, FlutterBackingStore backing_store_out, void *user_data)

typedef bool(*	FlutterBackingStoreCollectCallback) (const FlutterBackingStore renderer, void user_data)

typedef bool(*	FlutterLayersPresentCallback) (const FlutterLayer *layers, size_t layers_count, void user_data)

typedef bool(*	FlutterPresentViewCallback) (const FlutterPresentViewInfo *)

typedef const FlutterLocale (	FlutterComputePlatformResolvedLocaleCallback) (const FlutterLocale **, size_t)

typedef int64_t	FlutterEngineDartPort

typedef void(*	FlutterNativeThreadCallback) (FlutterNativeThreadType type, void *user_data)

typedef void(*	FlutterLogMessageCallback) (const char , const char , void *)

typedef struct _FlutterEngineAOTData *	FlutterEngineAOTData

typedef FlutterEngineResult(*	FlutterEngineCreateAOTDataFnPtr) (const FlutterEngineAOTDataSource source, FlutterEngineAOTData data_out)

typedef FlutterEngineResult(*	FlutterEngineCollectAOTDataFnPtr) (FlutterEngineAOTData data)

typedef FlutterEngineResult(*	FlutterEngineRunFnPtr) (size_t version, const FlutterRendererConfig config, const FlutterProjectArgs args, void user_data, FLUTTER_API_SYMBOL(FlutterEngine) engine_out)

typedef FlutterEngineResult(*	FlutterEngineShutdownFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine)

typedef FlutterEngineResult(*	FlutterEngineInitializeFnPtr) (size_t version, const FlutterRendererConfig config, const FlutterProjectArgs args, void user_data, FLUTTER_API_SYMBOL(FlutterEngine) engine_out)

typedef FlutterEngineResult(*	FlutterEngineDeinitializeFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine)

typedef FlutterEngineResult(*	FlutterEngineRunInitializedFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine)

typedef FlutterEngineResult(*	FlutterEngineSendWindowMetricsEventFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, const FlutterWindowMetricsEvent *event)

typedef FlutterEngineResult(*	FlutterEngineSendPointerEventFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, const FlutterPointerEvent *events, size_t events_count)

typedef FlutterEngineResult(*	FlutterEngineSendKeyEventFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, const FlutterKeyEvent event, FlutterKeyEventCallback callback, void user_data)

typedef FlutterEngineResult(*	FlutterEngineSendPlatformMessageFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, const FlutterPlatformMessage *message)

typedef FlutterEngineResult(*	FlutterEnginePlatformMessageCreateResponseHandleFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, FlutterDataCallback data_callback, void user_data, FlutterPlatformMessageResponseHandle *response_out)

typedef FlutterEngineResult(*	FlutterEnginePlatformMessageReleaseResponseHandleFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, FlutterPlatformMessageResponseHandle *response)

typedef FlutterEngineResult(*	FlutterEngineSendPlatformMessageResponseFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, const FlutterPlatformMessageResponseHandle handle, const uint8_t data, size_t data_length)

typedef FlutterEngineResult(*	FlutterEngineRegisterExternalTextureFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, int64_t texture_identifier)

typedef FlutterEngineResult(*	FlutterEngineUnregisterExternalTextureFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, int64_t texture_identifier)

typedef FlutterEngineResult(*	FlutterEngineMarkExternalTextureFrameAvailableFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, int64_t texture_identifier)

typedef FlutterEngineResult(*	FlutterEngineUpdateSemanticsEnabledFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, bool enabled)

typedef FlutterEngineResult(*	FlutterEngineUpdateAccessibilityFeaturesFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, FlutterAccessibilityFeature features)

typedef FlutterEngineResult(*	FlutterEngineDispatchSemanticsActionFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, uint64_t id, FlutterSemanticsAction action, const uint8_t *data, size_t data_length)

typedef FlutterEngineResult(*	FlutterEngineSendSemanticsActionFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, const FlutterSendSemanticsActionInfo *info)

typedef FlutterEngineResult(*	FlutterEngineOnVsyncFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, intptr_t baton, uint64_t frame_start_time_nanos, uint64_t frame_target_time_nanos)

typedef FlutterEngineResult(*	FlutterEngineReloadSystemFontsFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine)

typedef void(*	FlutterEngineTraceEventDurationBeginFnPtr) (const char *name)

typedef void(*	FlutterEngineTraceEventDurationEndFnPtr) (const char *name)

typedef void(*	FlutterEngineTraceEventInstantFnPtr) (const char *name)

typedef FlutterEngineResult(*	FlutterEnginePostRenderThreadTaskFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, VoidCallback callback, void *callback_data)

typedef uint64_t(*	FlutterEngineGetCurrentTimeFnPtr) ()

typedef FlutterEngineResult(*	FlutterEngineRunTaskFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, const FlutterTask *task)

typedef FlutterEngineResult(*	FlutterEngineUpdateLocalesFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, const FlutterLocale **locales, size_t locales_count)

typedef bool(*	FlutterEngineRunsAOTCompiledDartCodeFnPtr) (void)

typedef FlutterEngineResult(*	FlutterEnginePostDartObjectFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, FlutterEngineDartPort port, const FlutterEngineDartObject *object)

typedef FlutterEngineResult(*	FlutterEngineNotifyLowMemoryWarningFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine)

typedef FlutterEngineResult(*	FlutterEnginePostCallbackOnAllNativeThreadsFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, FlutterNativeThreadCallback callback, void *user_data)

typedef FlutterEngineResult(*	FlutterEngineNotifyDisplayUpdateFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, FlutterEngineDisplaysUpdateType update_type, const FlutterEngineDisplay *displays, size_t display_count)

typedef FlutterEngineResult(*	FlutterEngineScheduleFrameFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine)

typedef FlutterEngineResult(*	FlutterEngineSetNextFrameCallbackFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, VoidCallback callback, void *user_data)

typedef FlutterEngineResult(*	FlutterEngineAddViewFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, const FlutterAddViewInfo *info)

typedef FlutterEngineResult(*	FlutterEngineRemoveViewFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, const FlutterRemoveViewInfo *info)

typedef FlutterEngineResult(*	FlutterEngineSendViewFocusEventFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, const FlutterViewFocusEvent *event)

Enumerations
enum	FlutterEngineResult { kSuccess = 0 , kInvalidLibraryVersion , kInvalidArguments , kInternalInconsistency }

enum	FlutterRendererType { kOpenGL , kSoftware , kMetal , kVulkan }

enum	FlutterAccessibilityFeature { kFlutterAccessibilityFeatureAccessibleNavigation = 1 << 0 , kFlutterAccessibilityFeatureInvertColors = 1 << 1 , kFlutterAccessibilityFeatureDisableAnimations = 1 << 2 , kFlutterAccessibilityFeatureBoldText = 1 << 3 , kFlutterAccessibilityFeatureReduceMotion = 1 << 4 , kFlutterAccessibilityFeatureHighContrast = 1 << 5 , kFlutterAccessibilityFeatureOnOffSwitchLabels = 1 << 6 , kFlutterAccessibilityFeatureNoAnnounce = 1 << 7 }

enum	FlutterSemanticsAction { kFlutterSemanticsActionTap = 1 << 0 , kFlutterSemanticsActionLongPress = 1 << 1 , kFlutterSemanticsActionScrollLeft = 1 << 2 , kFlutterSemanticsActionScrollRight = 1 << 3 , kFlutterSemanticsActionScrollUp = 1 << 4 , kFlutterSemanticsActionScrollDown = 1 << 5 , kFlutterSemanticsActionIncrease = 1 << 6 , kFlutterSemanticsActionDecrease = 1 << 7 , kFlutterSemanticsActionShowOnScreen = 1 << 8 , kFlutterSemanticsActionMoveCursorForwardByCharacter = 1 << 9 , kFlutterSemanticsActionMoveCursorBackwardByCharacter = 1 << 10 , kFlutterSemanticsActionSetSelection = 1 << 11 , kFlutterSemanticsActionCopy = 1 << 12 , kFlutterSemanticsActionCut = 1 << 13 , kFlutterSemanticsActionPaste = 1 << 14 , kFlutterSemanticsActionDidGainAccessibilityFocus = 1 << 15 , kFlutterSemanticsActionDidLoseAccessibilityFocus = 1 << 16 , kFlutterSemanticsActionCustomAction = 1 << 17 , kFlutterSemanticsActionDismiss = 1 << 18 , kFlutterSemanticsActionMoveCursorForwardByWord = 1 << 19 , kFlutterSemanticsActionMoveCursorBackwardByWord = 1 << 20 , kFlutterSemanticsActionSetText = 1 << 21 , kFlutterSemanticsActionFocus = 1 << 22 , kFlutterSemanticsActionScrollToOffset = 1 << 23 , kFlutterSemanticsActionExpand = 1 << 24 , kFlutterSemanticsActionCollapse = 1 << 25 }

enum	FlutterSemanticsFlag { kFlutterSemanticsFlagHasCheckedState = 1 << 0 , kFlutterSemanticsFlagIsChecked = 1 << 1 , kFlutterSemanticsFlagIsSelected = 1 << 2 , kFlutterSemanticsFlagIsButton = 1 << 3 , kFlutterSemanticsFlagIsTextField = 1 << 4 , kFlutterSemanticsFlagIsFocused = 1 << 5 , kFlutterSemanticsFlagHasEnabledState = 1 << 6 , kFlutterSemanticsFlagIsEnabled = 1 << 7 , kFlutterSemanticsFlagIsInMutuallyExclusiveGroup = 1 << 8 , kFlutterSemanticsFlagIsHeader = 1 << 9 , kFlutterSemanticsFlagIsObscured = 1 << 10 , kFlutterSemanticsFlagScopesRoute = 1 << 11 , kFlutterSemanticsFlagNamesRoute = 1 << 12 , kFlutterSemanticsFlagIsHidden = 1 << 13 , kFlutterSemanticsFlagIsImage = 1 << 14 , kFlutterSemanticsFlagIsLiveRegion = 1 << 15 , kFlutterSemanticsFlagHasToggledState = 1 << 16 , kFlutterSemanticsFlagIsToggled = 1 << 17 , kFlutterSemanticsFlagHasImplicitScrolling = 1 << 18 , kFlutterSemanticsFlagIsMultiline = 1 << 19 , kFlutterSemanticsFlagIsReadOnly = 1 << 20 , kFlutterSemanticsFlagIsFocusable = 1 << 21 , kFlutterSemanticsFlagIsLink = 1 << 22 , kFlutterSemanticsFlagIsSlider = 1 << 23 , kFlutterSemanticsFlagIsKeyboardKey = 1 << 24 , kFlutterSemanticsFlagIsCheckStateMixed = 1 << 25 , kFlutterSemanticsFlagHasExpandedState = 1 << 26 , kFlutterSemanticsFlagIsExpanded = 1 << 27 , kFlutterSemanticsFlagHasSelectedState = 1 << 28 , kFlutterSemanticsFlagHasRequiredState = 1 << 29 , kFlutterSemanticsFlagIsRequired = 1 << 30 }

enum	FlutterTristate { kFlutterTristateNone , kFlutterTristateTrue , kFlutterTristateFalse }

enum	FlutterCheckState { kFlutterCheckStateNone , kFlutterCheckStateTrue , kFlutterCheckStateFalse , kFlutterCheckStateMixed }

enum	FlutterTextDirection { kFlutterTextDirectionUnknown = 0 , kFlutterTextDirectionRTL = 1 , kFlutterTextDirectionLTR = 2 }

enum	FlutterThreadPriority { kBackground = 0 , kNormal = 1 , kDisplay = 2 , kRaster = 3 }
	Valid values for priority of Thread. More...

enum	FlutterOpenGLTargetType { kFlutterOpenGLTargetTypeTexture , kFlutterOpenGLTargetTypeFramebuffer , kFlutterOpenGLTargetTypeSurface }

enum	FlutterSoftwarePixelFormat { kFlutterSoftwarePixelFormatGray8 , kFlutterSoftwarePixelFormatRGB565 , kFlutterSoftwarePixelFormatRGBA4444 , kFlutterSoftwarePixelFormatRGBA8888 , kFlutterSoftwarePixelFormatRGBX8888 , kFlutterSoftwarePixelFormatBGRA8888 , kFlutterSoftwarePixelFormatNative32 }

enum	FlutterMetalExternalTexturePixelFormat { kYUVA , kRGBA }
	Pixel format for the external texture. More...

enum	FlutterMetalExternalTextureYUVColorSpace { kBT601FullRange , kBT601LimitedRange }
	YUV color space for the YUV external texture. More...

enum	FlutterViewFocusDirection { kUndefined , kForward , kBackward }

enum	FlutterViewFocusState { kUnfocused , kFocused }
	Represents the focus state of a given [FlutterView]. More...

enum	FlutterPointerPhase { kCancel , kUp , kDown , kMove , kAdd , kRemove , kHover , kPanZoomStart , kPanZoomUpdate , kPanZoomEnd }
	The phase of the pointer event. More...

enum	FlutterPointerDeviceKind { kFlutterPointerDeviceKindMouse = 1 , kFlutterPointerDeviceKindTouch , kFlutterPointerDeviceKindStylus , kFlutterPointerDeviceKindTrackpad }
	The device type that created a pointer event. More...

enum	FlutterPointerMouseButtons { kFlutterPointerButtonMousePrimary = 1 << 0 , kFlutterPointerButtonMouseSecondary = 1 << 1 , kFlutterPointerButtonMouseMiddle = 1 << 2 , kFlutterPointerButtonMouseBack = 1 << 3 , kFlutterPointerButtonMouseForward = 1 << 4 }

enum	FlutterPointerSignalKind { kFlutterPointerSignalKindNone , kFlutterPointerSignalKindScroll , kFlutterPointerSignalKindScrollInertiaCancel , kFlutterPointerSignalKindScale }
	The type of a pointer signal. More...

enum	FlutterKeyEventType { kFlutterKeyEventTypeUp = 1 , kFlutterKeyEventTypeDown , kFlutterKeyEventTypeRepeat }

enum	FlutterKeyEventDeviceType { kFlutterKeyEventDeviceTypeKeyboard = 1 , kFlutterKeyEventDeviceTypeDirectionalPad , kFlutterKeyEventDeviceTypeGamepad , kFlutterKeyEventDeviceTypeJoystick , kFlutterKeyEventDeviceTypeHdmi }

enum	FlutterStringAttributeType { kSpellOut , kLocale }

enum	FlutterPlatformViewMutationType { kFlutterPlatformViewMutationTypeOpacity , kFlutterPlatformViewMutationTypeClipRect , kFlutterPlatformViewMutationTypeClipRoundedRect , kFlutterPlatformViewMutationTypeTransformation }

enum	FlutterBackingStoreType { kFlutterBackingStoreTypeOpenGL , kFlutterBackingStoreTypeSoftware , kFlutterBackingStoreTypeMetal , kFlutterBackingStoreTypeVulkan , kFlutterBackingStoreTypeSoftware2 }

enum	FlutterLayerContentType { kFlutterLayerContentTypeBackingStore , kFlutterLayerContentTypePlatformView }

enum	FlutterEngineDisplaysUpdateType { kFlutterEngineDisplaysUpdateTypeStartup , kFlutterEngineDisplaysUpdateTypeCount }

enum	FlutterEngineDartObjectType { kFlutterEngineDartObjectTypeNull , kFlutterEngineDartObjectTypeBool , kFlutterEngineDartObjectTypeInt32 , kFlutterEngineDartObjectTypeInt64 , kFlutterEngineDartObjectTypeDouble , kFlutterEngineDartObjectTypeString , kFlutterEngineDartObjectTypeBuffer }

enum	FlutterNativeThreadType { kFlutterNativeThreadTypePlatform , kFlutterNativeThreadTypeRender , kFlutterNativeThreadTypeUI , kFlutterNativeThreadTypeWorker }

enum	FlutterEngineAOTDataSourceType { kFlutterEngineAOTDataSourceTypeElfPath }
	AOT data source type. More...

Functions
FLUTTER_EXPORT FlutterEngineResult	FlutterEngineCreateAOTData (const FlutterEngineAOTDataSource source, FlutterEngineAOTData data_out)
	Creates the necessary data structures to launch a Flutter Dart application in AOT mode. The data may only be collected after all FlutterEngine instances launched using this data have been terminated.

FLUTTER_EXPORT FlutterEngineResult	FlutterEngineCollectAOTData (FlutterEngineAOTData data)
	Collects the AOT data.

FLUTTER_EXPORT FlutterEngineResult	FlutterEngineRun (size_t version, const FlutterRendererConfig config, const FlutterProjectArgs args, void user_data, FLUTTER_API_SYMBOL(FlutterEngine) engine_out)
	Initialize and run a Flutter engine instance and return a handle to it. This is a convenience method for the pair of calls to `FlutterEngineInitialize` and `FlutterEngineRunInitialized`.

FLUTTER_EXPORT FlutterEngineResult	FlutterEngineShutdown (FLUTTER_API_SYMBOL(FlutterEngine) engine)
	Shuts down a Flutter engine instance. The engine handle is no longer valid for any calls in the embedder API after this point. Making additional calls with this handle is undefined behavior.

FLUTTER_EXPORT FlutterEngineResult	FlutterEngineInitialize (size_t version, const FlutterRendererConfig config, const FlutterProjectArgs args, void user_data, FLUTTER_API_SYMBOL(FlutterEngine) engine_out)
	Initialize a Flutter engine instance. This does not run the Flutter application code till the `FlutterEngineRunInitialized` call is made. Besides Flutter application code, no tasks are scheduled on embedder managed task runners either. This allows embedders providing custom task runners to the Flutter engine to obtain a handle to the Flutter engine before the engine can post tasks on these task runners.

FLUTTER_EXPORT FlutterEngineResult	FlutterEngineDeinitialize (FLUTTER_API_SYMBOL(FlutterEngine) engine)
	Stops running the Flutter engine instance. After this call, the embedder is also guaranteed that no more calls to post tasks onto custom task runners specified by the embedder are made. The Flutter engine handle still needs to be collected via a call to `FlutterEngineShutdown`.

FLUTTER_EXPORT FlutterEngineResult	FlutterEngineRunInitialized (FLUTTER_API_SYMBOL(FlutterEngine) engine)
	Runs an initialized engine instance. An engine can be initialized via `FlutterEngineInitialize`. An initialized instance can only be run once. During and after this call, custom task runners supplied by the embedder are expected to start servicing tasks.

FLUTTER_EXPORT FlutterEngineResult	FlutterEngineAddView (FLUTTER_API_SYMBOL(FlutterEngine) engine, const FlutterAddViewInfo *info)
	Adds a view.

FLUTTER_EXPORT FlutterEngineResult	FlutterEngineRemoveView (FLUTTER_API_SYMBOL(FlutterEngine) engine, const FlutterRemoveViewInfo *info)
	Removes a view.

FLUTTER_EXPORT FlutterEngineResult	FlutterEngineSendViewFocusEvent (FLUTTER_API_SYMBOL(FlutterEngine) engine, const FlutterViewFocusEvent *event)
	Notifies the engine that platform view focus state has changed.

FLUTTER_EXPORT FlutterEngineResult	FlutterEngineSendWindowMetricsEvent (FLUTTER_API_SYMBOL(FlutterEngine) engine, const FlutterWindowMetricsEvent *event)

FLUTTER_EXPORT FlutterEngineResult	FlutterEngineSendPointerEvent (FLUTTER_API_SYMBOL(FlutterEngine) engine, const FlutterPointerEvent *events, size_t events_count)

FLUTTER_EXPORT FlutterEngineResult	FlutterEngineSendKeyEvent (FLUTTER_API_SYMBOL(FlutterEngine) engine, const FlutterKeyEvent event, FlutterKeyEventCallback callback, void user_data)
	Sends a key event to the engine. The framework will decide whether to handle this event in a synchronous fashion, although due to technical limitation, the result is always reported asynchronously. The `callback` is guaranteed to be called exactly once.

FLUTTER_EXPORT FlutterEngineResult	FlutterEngineSendPlatformMessage (FLUTTER_API_SYMBOL(FlutterEngine) engine, const FlutterPlatformMessage *message)

FLUTTER_EXPORT FlutterEngineResult	FlutterPlatformMessageCreateResponseHandle (FLUTTER_API_SYMBOL(FlutterEngine) engine, FlutterDataCallback data_callback, void user_data, FlutterPlatformMessageResponseHandle *response_out)
	Creates a platform message response handle that allows the embedder to set a native callback for a response to a message. This handle may be set on the `response_handle` field of any `FlutterPlatformMessage` sent to the engine.

FLUTTER_EXPORT FlutterEngineResult	FlutterPlatformMessageReleaseResponseHandle (FLUTTER_API_SYMBOL(FlutterEngine) engine, FlutterPlatformMessageResponseHandle *response)
	Collects the handle created using `FlutterPlatformMessageCreateResponseHandle`.

FLUTTER_EXPORT FlutterEngineResult	FlutterEngineSendPlatformMessageResponse (FLUTTER_API_SYMBOL(FlutterEngine) engine, const FlutterPlatformMessageResponseHandle handle, const uint8_t data, size_t data_length)
	Send a response from the native side to a platform message from the Dart Flutter application.

FLUTTER_EXPORT FlutterEngineResult	__FlutterEngineFlushPendingTasksNow ()
	This API is only meant to be used by platforms that need to flush tasks on a message loop not controlled by the Flutter engine.

FLUTTER_EXPORT FlutterEngineResult	FlutterEngineRegisterExternalTexture (FLUTTER_API_SYMBOL(FlutterEngine) engine, int64_t texture_identifier)
	Register an external texture with a unique (per engine) identifier. Only rendering backends that support external textures accept external texture registrations. After the external texture is registered, the application can mark that a frame is available by calling `FlutterEngineMarkExternalTextureFrameAvailable`.

FLUTTER_EXPORT FlutterEngineResult	FlutterEngineUnregisterExternalTexture (FLUTTER_API_SYMBOL(FlutterEngine) engine, int64_t texture_identifier)
	Unregister a previous texture registration.

FLUTTER_EXPORT FlutterEngineResult	FlutterEngineMarkExternalTextureFrameAvailable (FLUTTER_API_SYMBOL(FlutterEngine) engine, int64_t texture_identifier)
	Mark that a new texture frame is available for a given texture identifier.

FLUTTER_EXPORT FlutterEngineResult	FlutterEngineUpdateSemanticsEnabled (FLUTTER_API_SYMBOL(FlutterEngine) engine, bool enabled)
	Enable or disable accessibility semantics.

FLUTTER_EXPORT FlutterEngineResult	FlutterEngineUpdateAccessibilityFeatures (FLUTTER_API_SYMBOL(FlutterEngine) engine, FlutterAccessibilityFeature features)
	Sets additional accessibility features.

FLUTTER_EXPORT FlutterEngineResult	FlutterEngineDispatchSemanticsAction (FLUTTER_API_SYMBOL(FlutterEngine) engine, uint64_t node_id, FlutterSemanticsAction action, const uint8_t *data, size_t data_length)
	Dispatch a semantics action to the specified semantics node in the implicit view.

FLUTTER_EXPORT FlutterEngineResult	FlutterEngineSendSemanticsAction (FLUTTER_API_SYMBOL(FlutterEngine) engine, const FlutterSendSemanticsActionInfo *info)
	Dispatch a semantics action to the specified semantics node within a specific view.

FLUTTER_EXPORT FlutterEngineResult	FlutterEngineOnVsync (FLUTTER_API_SYMBOL(FlutterEngine) engine, intptr_t baton, uint64_t frame_start_time_nanos, uint64_t frame_target_time_nanos)
	Notify the engine that a vsync event occurred. A baton passed to the platform via the vsync callback must be returned. This call must be made on the thread on which the call to `FlutterEngineRun` was made.

FLUTTER_EXPORT FlutterEngineResult	FlutterEngineReloadSystemFonts (FLUTTER_API_SYMBOL(FlutterEngine) engine)
	Reloads the system fonts in engine.

FLUTTER_EXPORT void	FlutterEngineTraceEventDurationBegin (const char *name)
	A profiling utility. Logs a trace duration begin event to the timeline. If the timeline is unavailable or disabled, this has no effect. Must be balanced with an duration end event (via `FlutterEngineTraceEventDurationEnd`) with the same name on the same thread. Can be called on any thread. Strings passed into the function will NOT be copied when added to the timeline. Only string literals may be passed in.

FLUTTER_EXPORT void	FlutterEngineTraceEventDurationEnd (const char *name)
	A profiling utility. Logs a trace duration end event to the timeline. If the timeline is unavailable or disabled, this has no effect. This call must be preceded by a trace duration begin call (via `FlutterEngineTraceEventDurationBegin`) with the same name on the same thread. Can be called on any thread. Strings passed into the function will NOT be copied when added to the timeline. Only string literals may be passed in.

FLUTTER_EXPORT void	FlutterEngineTraceEventInstant (const char *name)
	A profiling utility. Logs a trace duration instant event to the timeline. If the timeline is unavailable or disabled, this has no effect. Can be called on any thread. Strings passed into the function will NOT be copied when added to the timeline. Only string literals may be passed in.

FLUTTER_EXPORT FlutterEngineResult	FlutterEnginePostRenderThreadTask (FLUTTER_API_SYMBOL(FlutterEngine) engine, VoidCallback callback, void *callback_data)
	Posts a task onto the Flutter render thread. Typically, this may be called from any thread as long as a `FlutterEngineShutdown` on the specific engine has not already been initiated.

FLUTTER_EXPORT uint64_t	FlutterEngineGetCurrentTime ()
	Get the current time in nanoseconds from the clock used by the flutter engine. This is the system monotonic clock.

FLUTTER_EXPORT FlutterEngineResult	FlutterEngineRunTask (FLUTTER_API_SYMBOL(FlutterEngine) engine, const FlutterTask *task)
	Inform the engine to run the specified task. This task has been given to the embedder via the `FlutterTaskRunnerDescription.post_task_callback`. This call must only be made at the target time specified in that callback. Running the task before that time is undefined behavior.

FLUTTER_EXPORT FlutterEngineResult	FlutterEngineUpdateLocales (FLUTTER_API_SYMBOL(FlutterEngine) engine, const FlutterLocale **locales, size_t locales_count)
	Notify a running engine instance that the locale has been updated. The preferred locale must be the first item in the list of locales supplied. The other entries will be used as a fallback.

FLUTTER_EXPORT bool	FlutterEngineRunsAOTCompiledDartCode (void)
	Returns if the Flutter engine instance will run AOT compiled Dart code. This call has no threading restrictions.

FLUTTER_EXPORT FlutterEngineResult	FlutterEnginePostDartObject (FLUTTER_API_SYMBOL(FlutterEngine) engine, FlutterEngineDartPort port, const FlutterEngineDartObject *object)
	Posts a Dart object to specified send port. The corresponding receive port for send port can be in any isolate running in the VM. This isolate can also be the root isolate for an unrelated engine. The engine parameter is necessary only to ensure the call is not made when no engine (and hence no VM) is running.

FLUTTER_EXPORT FlutterEngineResult	FlutterEngineNotifyLowMemoryWarning (FLUTTER_API_SYMBOL(FlutterEngine) engine)
	Posts a low memory notification to a running engine instance. The engine will do its best to release non-critical resources in response. It is not guaranteed that the resource would have been collected by the time this call returns however. The notification is posted to engine subsystems that may be operating on other threads.

FLUTTER_EXPORT FlutterEngineResult	FlutterEnginePostCallbackOnAllNativeThreads (FLUTTER_API_SYMBOL(FlutterEngine) engine, FlutterNativeThreadCallback callback, void *user_data)
	Schedule a callback to be run on all engine managed threads. The engine will attempt to service this callback the next time the message loop for each managed thread is idle. Since the engine manages the entire lifecycle of multiple threads, there is no opportunity for the embedders to finely tune the priorities of threads directly, or, perform other thread specific configuration (for example, setting thread names for tracing). This callback gives embedders a chance to affect such tuning.

FLUTTER_EXPORT FlutterEngineResult	FlutterEngineNotifyDisplayUpdate (FLUTTER_API_SYMBOL(FlutterEngine) engine, FlutterEngineDisplaysUpdateType update_type, const FlutterEngineDisplay *displays, size_t display_count)
	Posts updates corresponding to display changes to a running engine instance.

FLUTTER_EXPORT FlutterEngineResult	FlutterEngineScheduleFrame (FLUTTER_API_SYMBOL(FlutterEngine) engine)
	Schedule a new frame to redraw the content.

FLUTTER_EXPORT FlutterEngineResult	FlutterEngineSetNextFrameCallback (FLUTTER_API_SYMBOL(FlutterEngine) engine, VoidCallback callback, void *user_data)
	Schedule a callback to be called after the next frame is drawn. This must be called from the platform thread. The callback is executed only once from the raster thread; embedders must re-thread if necessary. Performing blocking calls in this callback may introduce application jank.

FLUTTER_EXPORT FlutterEngineResult	FlutterEngineGetProcAddresses (FlutterEngineProcTable *table)
	Gets the table of engine function pointers.

Variables
FLUTTER_EXPORT const int32_t	kFlutterSemanticsNodeIdBatchEnd

FLUTTER_EXPORT const int32_t	kFlutterSemanticsCustomActionIdBatchEnd

Macro Definition Documentation

◆ FLUTTER_API_SYMBOL

#define FLUTTER_API_SYMBOL ( symbol ) symbol

Definition at line 67 of file embedder.h.

◆ FLUTTER_ENGINE_VERSION

#define FLUTTER_ENGINE_VERSION 1

Definition at line 70 of file embedder.h.

◆ FLUTTER_EXPORT

#define FLUTTER_EXPORT

Definition at line 57 of file embedder.h.

Typedef Documentation

◆ BoolCallback

typedef bool(* BoolCallback) (void *)

Definition at line 610 of file embedder.h.

◆ BoolPresentInfoCallback

typedef bool(* BoolPresentInfoCallback) (void *, const FlutterPresentInfo *)

Callback for when a surface is presented.

Definition at line 713 of file embedder.h.

◆ FLUTTER_API_SYMBOL

typedef struct _FlutterEngine * FLUTTER_API_SYMBOL(FlutterEngine)

Definition at line 380 of file embedder.h.

◆ FlutterAddViewCallback

typedef void(* FlutterAddViewCallback) (const FlutterAddViewResult *result)

The callback invoked by the engine when the engine has attempted to add a view.

The |FlutterAddViewResult| is only guaranteed to be valid during this callback.

Definition at line 1089 of file embedder.h.

◆ FlutterBackingStoreCollectCallback

typedef bool(* FlutterBackingStoreCollectCallback) (const FlutterBackingStore *renderer, void *user_data)

Definition at line 2181 of file embedder.h.

◆ FlutterBackingStoreCreateCallback

typedef bool(* FlutterBackingStoreCreateCallback) (const FlutterBackingStoreConfig *config, FlutterBackingStore *backing_store_out, void *user_data)

Definition at line 2176 of file embedder.h.

◆ FlutterChannelUpdateCallback

typedef void(* FlutterChannelUpdateCallback) (const FlutterChannelUpdate *, void *)

Definition at line 1838 of file embedder.h.

◆ FlutterComputePlatformResolvedLocaleCallback

typedef const FlutterLocale *(* FlutterComputePlatformResolvedLocaleCallback) (const FlutterLocale **, size_t)

Callback that returns the system locale.

Embedders that implement this callback should return the FlutterLocale from the supported_locales list that most closely matches the user/device's preferred locale.

This callback does not currently provide the user_data baton. https://github.com/flutter/flutter/issues/79826

Definition at line 2285 of file embedder.h.

◆ FlutterDataCallback

typedef void(* FlutterDataCallback) (const uint8_t *, size_t, void *)

Definition at line 1453 of file embedder.h.

◆ FlutterEngineAddViewFnPtr

typedef FlutterEngineResult(* FlutterEngineAddViewFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, const FlutterAddViewInfo *info)

Definition at line 3693 of file embedder.h.

◆ FlutterEngineAOTData

typedef struct _FlutterEngineAOTData* FlutterEngineAOTData

An opaque object that describes the AOT data that can be used to launch a FlutterEngine instance in AOT mode.

Definition at line 2454 of file embedder.h.

◆ FlutterEngineCollectAOTDataFnPtr

typedef FlutterEngineResult(* FlutterEngineCollectAOTDataFnPtr) (FlutterEngineAOTData data)

Definition at line 3574 of file embedder.h.

◆ FlutterEngineCreateAOTDataFnPtr

typedef FlutterEngineResult(* FlutterEngineCreateAOTDataFnPtr) (const FlutterEngineAOTDataSource *source, FlutterEngineAOTData *data_out)

Definition at line 3571 of file embedder.h.

◆ FlutterEngineDartPort

typedef int64_t FlutterEngineDartPort

Definition at line 2328 of file embedder.h.

◆ FlutterEngineDeinitializeFnPtr

typedef FlutterEngineResult(* FlutterEngineDeinitializeFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine)

Definition at line 3590 of file embedder.h.

◆ FlutterEngineDispatchSemanticsActionFnPtr

typedef FlutterEngineResult(* FlutterEngineDispatchSemanticsActionFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, uint64_t id, FlutterSemanticsAction action, const uint8_t *data, size_t data_length)

Definition at line 3640 of file embedder.h.

◆ FlutterEngineDisplayId

typedef uint64_t FlutterEngineDisplayId

Display refers to a graphics hardware system consisting of a framebuffer, typically a monitor or a screen. This ID is unique per display and is stable until the Flutter application restarts.

Definition at line 1043 of file embedder.h.

◆ FlutterEngineGetCurrentTimeFnPtr

typedef uint64_t(* FlutterEngineGetCurrentTimeFnPtr) ()

Definition at line 3663 of file embedder.h.

◆ FlutterEngineInitializeFnPtr

typedef FlutterEngineResult(* FlutterEngineInitializeFnPtr) (size_t version, const FlutterRendererConfig *config, const FlutterProjectArgs *args, void *user_data, FLUTTER_API_SYMBOL(FlutterEngine) *engine_out)

Definition at line 3584 of file embedder.h.

◆ FlutterEngineMarkExternalTextureFrameAvailableFnPtr

typedef FlutterEngineResult( * FlutterEngineMarkExternalTextureFrameAvailableFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, int64_t texture_identifier)

Definition at line 3630 of file embedder.h.

◆ FlutterEngineNotifyDisplayUpdateFnPtr

typedef FlutterEngineResult(* FlutterEngineNotifyDisplayUpdateFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, FlutterEngineDisplaysUpdateType update_type, const FlutterEngineDisplay *displays, size_t display_count)

Definition at line 3682 of file embedder.h.

◆ FlutterEngineNotifyLowMemoryWarningFnPtr

typedef FlutterEngineResult(* FlutterEngineNotifyLowMemoryWarningFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine)

Definition at line 3676 of file embedder.h.

◆ FlutterEngineOnVsyncFnPtr

typedef FlutterEngineResult(* FlutterEngineOnVsyncFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, intptr_t baton, uint64_t frame_start_time_nanos, uint64_t frame_target_time_nanos)

Definition at line 3649 of file embedder.h.

◆ FlutterEnginePlatformMessageCreateResponseHandleFnPtr

typedef FlutterEngineResult( * FlutterEnginePlatformMessageCreateResponseHandleFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, FlutterDataCallback data_callback, void *user_data, FlutterPlatformMessageResponseHandle **response_out)

Definition at line 3609 of file embedder.h.

◆ FlutterEnginePlatformMessageReleaseResponseHandleFnPtr

typedef FlutterEngineResult( * FlutterEnginePlatformMessageReleaseResponseHandleFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, FlutterPlatformMessageResponseHandle *response)

Definition at line 3615 of file embedder.h.

◆ FlutterEnginePostCallbackOnAllNativeThreadsFnPtr

typedef FlutterEngineResult(* FlutterEnginePostCallbackOnAllNativeThreadsFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, FlutterNativeThreadCallback callback, void *user_data)

Definition at line 3678 of file embedder.h.

◆ FlutterEnginePostDartObjectFnPtr

typedef FlutterEngineResult(* FlutterEnginePostDartObjectFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, FlutterEngineDartPort port, const FlutterEngineDartObject *object)

Definition at line 3672 of file embedder.h.

◆ FlutterEnginePostRenderThreadTaskFnPtr

typedef FlutterEngineResult(* FlutterEnginePostRenderThreadTaskFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, VoidCallback callback, void *callback_data)

Definition at line 3659 of file embedder.h.

◆ FlutterEngineRegisterExternalTextureFnPtr

typedef FlutterEngineResult(* FlutterEngineRegisterExternalTextureFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, int64_t texture_identifier)

Definition at line 3624 of file embedder.h.

◆ FlutterEngineReloadSystemFontsFnPtr

typedef FlutterEngineResult(* FlutterEngineReloadSystemFontsFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine)

Definition at line 3654 of file embedder.h.

◆ FlutterEngineRemoveViewFnPtr

typedef FlutterEngineResult(* FlutterEngineRemoveViewFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, const FlutterRemoveViewInfo *info)

Definition at line 3696 of file embedder.h.

◆ FlutterEngineRunFnPtr

typedef FlutterEngineResult(* FlutterEngineRunFnPtr) (size_t version, const FlutterRendererConfig *config, const FlutterProjectArgs *args, void *user_data, FLUTTER_API_SYMBOL(FlutterEngine) *engine_out)

Definition at line 3576 of file embedder.h.

◆ FlutterEngineRunInitializedFnPtr

typedef FlutterEngineResult(* FlutterEngineRunInitializedFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine)

Definition at line 3592 of file embedder.h.

◆ FlutterEngineRunsAOTCompiledDartCodeFnPtr

typedef bool(* FlutterEngineRunsAOTCompiledDartCodeFnPtr) (void)

Definition at line 3671 of file embedder.h.

◆ FlutterEngineRunTaskFnPtr

typedef FlutterEngineResult(* FlutterEngineRunTaskFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, const FlutterTask *task)

Definition at line 3664 of file embedder.h.

◆ FlutterEngineScheduleFrameFnPtr

typedef FlutterEngineResult(* FlutterEngineScheduleFrameFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine)

Definition at line 3687 of file embedder.h.

◆ FlutterEngineSendKeyEventFnPtr

typedef FlutterEngineResult(* FlutterEngineSendKeyEventFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, const FlutterKeyEvent *event, FlutterKeyEventCallback callback, void *user_data)

Definition at line 3601 of file embedder.h.

◆ FlutterEngineSendPlatformMessageFnPtr

typedef FlutterEngineResult(* FlutterEngineSendPlatformMessageFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, const FlutterPlatformMessage *message)

Definition at line 3606 of file embedder.h.

◆ FlutterEngineSendPlatformMessageResponseFnPtr

typedef FlutterEngineResult(* FlutterEngineSendPlatformMessageResponseFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, const FlutterPlatformMessageResponseHandle *handle, const uint8_t *data, size_t data_length)

Definition at line 3619 of file embedder.h.

◆ FlutterEngineSendPointerEventFnPtr

typedef FlutterEngineResult(* FlutterEngineSendPointerEventFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, const FlutterPointerEvent *events, size_t events_count)

Definition at line 3597 of file embedder.h.

◆ FlutterEngineSendSemanticsActionFnPtr

typedef FlutterEngineResult(* FlutterEngineSendSemanticsActionFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, const FlutterSendSemanticsActionInfo *info)

Definition at line 3646 of file embedder.h.

◆ FlutterEngineSendViewFocusEventFnPtr

typedef FlutterEngineResult(* FlutterEngineSendViewFocusEventFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, const FlutterViewFocusEvent *event)

Definition at line 3699 of file embedder.h.

◆ FlutterEngineSendWindowMetricsEventFnPtr

typedef FlutterEngineResult(* FlutterEngineSendWindowMetricsEventFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, const FlutterWindowMetricsEvent *event)

Definition at line 3594 of file embedder.h.

◆ FlutterEngineSetNextFrameCallbackFnPtr

typedef FlutterEngineResult(* FlutterEngineSetNextFrameCallbackFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, VoidCallback callback, void *user_data)

Definition at line 3689 of file embedder.h.

◆ FlutterEngineShutdownFnPtr

typedef FlutterEngineResult(* FlutterEngineShutdownFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine)

Definition at line 3582 of file embedder.h.

◆ FlutterEngineTraceEventDurationBeginFnPtr

typedef void(* FlutterEngineTraceEventDurationBeginFnPtr) (const char *name)

Definition at line 3656 of file embedder.h.

◆ FlutterEngineTraceEventDurationEndFnPtr

typedef void(* FlutterEngineTraceEventDurationEndFnPtr) (const char *name)

Definition at line 3657 of file embedder.h.

◆ FlutterEngineTraceEventInstantFnPtr

typedef void(* FlutterEngineTraceEventInstantFnPtr) (const char *name)

Definition at line 3658 of file embedder.h.

◆ FlutterEngineUnregisterExternalTextureFnPtr

typedef FlutterEngineResult(* FlutterEngineUnregisterExternalTextureFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, int64_t texture_identifier)

Definition at line 3627 of file embedder.h.

◆ FlutterEngineUpdateAccessibilityFeaturesFnPtr

typedef FlutterEngineResult(* FlutterEngineUpdateAccessibilityFeaturesFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, FlutterAccessibilityFeature features)

Definition at line 3637 of file embedder.h.

◆ FlutterEngineUpdateLocalesFnPtr

typedef FlutterEngineResult(* FlutterEngineUpdateLocalesFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, const FlutterLocale **locales, size_t locales_count)

Definition at line 3667 of file embedder.h.

◆ FlutterEngineUpdateSemanticsEnabledFnPtr

typedef FlutterEngineResult(* FlutterEngineUpdateSemanticsEnabledFnPtr) (FLUTTER_API_SYMBOL(FlutterEngine) engine, bool enabled)

Definition at line 3634 of file embedder.h.

◆ FlutterFrameBufferWithDamageCallback

typedef void(* FlutterFrameBufferWithDamageCallback) (void *, const intptr_t, FlutterDamage *)

Callback for when a frame buffer object is requested with necessary information for partial repaint.

Definition at line 693 of file embedder.h.

◆ FlutterKeyEventCallback

typedef void(* FlutterKeyEventCallback) (bool, void *)

Definition at line 1427 of file embedder.h.

◆ FlutterLayersPresentCallback

typedef bool(* FlutterLayersPresentCallback) (const FlutterLayer **layers, size_t layers_count, void *user_data)

Definition at line 2185 of file embedder.h.

◆ FlutterLogMessageCallback

typedef void(* FlutterLogMessageCallback) (const char *, const char *, void *)

Definition at line 2448 of file embedder.h.

◆ FlutterMetalCommandQueueHandle

typedef const void* FlutterMetalCommandQueueHandle

Alias for id<MTLCommandQueue>.

Definition at line 803 of file embedder.h.

◆ FlutterMetalDeviceHandle

typedef const void* FlutterMetalDeviceHandle

Alias for id<MTLDevice>.

Definition at line 800 of file embedder.h.

◆ FlutterMetalPresentCallback

typedef bool(* FlutterMetalPresentCallback) (void *, const FlutterMetalTexture *)

Callback for when a metal texture is presented. The texture_id here corresponds to the texture_id provided by the embedder in the FlutterMetalTextureCallback callback.

Definition at line 883 of file embedder.h.

◆ FlutterMetalTextureCallback

typedef FlutterMetalTexture(* FlutterMetalTextureCallback) (void *, const FlutterFrameInfo *)

Callback for when a metal texture is requested.

Definition at line 876 of file embedder.h.

◆ FlutterMetalTextureFrameCallback

typedef bool(* FlutterMetalTextureFrameCallback) (void *, int64_t, size_t, size_t, FlutterMetalExternalTexture *)

Callback to provide an external texture for a given texture_id. See: external_texture_frame_callback.

Definition at line 846 of file embedder.h.

◆ FlutterMetalTextureHandle

typedef const void* FlutterMetalTextureHandle

Alias for id<MTLTexture>.

Definition at line 806 of file embedder.h.

◆ FlutterNativeThreadCallback

typedef void(* FlutterNativeThreadCallback) (FlutterNativeThreadType type, void *user_data)

A callback made by the engine in response to FlutterEnginePostCallbackOnAllNativeThreads on all internal thread.

Definition at line 2423 of file embedder.h.

◆ FlutterOpenGLSurfaceCallback

typedef bool(* FlutterOpenGLSurfaceCallback) (void *, bool *)

Definition at line 554 of file embedder.h.

◆ FlutterPlatformMessageCallback

typedef void(* FlutterPlatformMessageCallback) (const FlutterPlatformMessage *, void *)

Definition at line 1449 of file embedder.h.

◆ FlutterPlatformMessageResponseHandle

typedef struct _FlutterPlatformMessageResponseHandle FlutterPlatformMessageResponseHandle

Definition at line 1432 of file embedder.h.

◆ FlutterPlatformViewIdentifier

typedef int64_t FlutterPlatformViewIdentifier

The identifier of the platform view. This identifier is specified by the application when a platform view is added to the scene via the SceneBuilder.addPlatformView call.

Definition at line 1460 of file embedder.h.

◆ FlutterPresentViewCallback

typedef bool(* FlutterPresentViewCallback) (const FlutterPresentViewInfo *)

The callback invoked when the embedder should present to a view.

The |FlutterPresentViewInfo| will be deallocated once the callback returns.

Definition at line 2192 of file embedder.h.

◆ FlutterRemoveViewCallback

typedef void(* FlutterRemoveViewCallback) (const FlutterRemoveViewResult *)

The callback invoked by the engine when the engine has attempted to remove a view.

The |FlutterRemoveViewResult| is only guaranteed to be valid during this callback.

Definition at line 1137 of file embedder.h.

◆ FlutterTaskRunner

typedef struct _FlutterTaskRunner* FlutterTaskRunner

Definition at line 1846 of file embedder.h.

◆ FlutterTaskRunnerPostTaskCallback

typedef void(* FlutterTaskRunnerPostTaskCallback) (FlutterTask, uint64_t, void *)

Definition at line 1853 of file embedder.h.

◆ FlutterUpdateSemanticsCallback

typedef void(* FlutterUpdateSemanticsCallback) (const FlutterSemanticsUpdate *, void *)

Definition at line 1820 of file embedder.h.

◆ FlutterUpdateSemanticsCallback2

typedef void(* FlutterUpdateSemanticsCallback2) (const FlutterSemanticsUpdate2 *, void *)

Definition at line 1824 of file embedder.h.

◆ FlutterUpdateSemanticsCustomActionCallback

typedef void(* FlutterUpdateSemanticsCustomActionCallback) (const FlutterSemanticsCustomAction *, void *)

Definition at line 1816 of file embedder.h.

◆ FlutterUpdateSemanticsNodeCallback

typedef void(* FlutterUpdateSemanticsNodeCallback) (const FlutterSemanticsNode *, void *)

Definition at line 1812 of file embedder.h.

◆ FlutterViewFocusChangeRequestCallback

typedef void(* FlutterViewFocusChangeRequestCallback) (const FlutterViewFocusChangeRequest *, void *)

Definition at line 1842 of file embedder.h.

◆ FlutterViewId

typedef int64_t FlutterViewId

Unique identifier for views.

View IDs are generated by the embedder and are opaque to the engine; the engine does not interpret view IDs in any way.

Definition at line 386 of file embedder.h.

◆ FlutterVulkanDeviceHandle

typedef void* FlutterVulkanDeviceHandle

Alias for VkDevice.

Definition at line 918 of file embedder.h.

◆ FlutterVulkanImageCallback

typedef FlutterVulkanImage(* FlutterVulkanImageCallback) (void *, const FlutterFrameInfo *)

Callback for when a VkImage is requested.

Definition at line 944 of file embedder.h.

◆ FlutterVulkanImageHandle

typedef uint64_t FlutterVulkanImageHandle

Alias for VkImage.

Definition at line 924 of file embedder.h.

◆ FlutterVulkanInstanceHandle

typedef void* FlutterVulkanInstanceHandle

Alias for VkInstance.

Definition at line 912 of file embedder.h.

◆ FlutterVulkanInstanceProcAddressCallback

typedef void *(* FlutterVulkanInstanceProcAddressCallback) (void *, FlutterVulkanInstanceHandle, const char *)

Callback to fetch a Vulkan function pointer for a given instance. Normally, this should return the results of vkGetInstanceProcAddr.

Definition at line 938 of file embedder.h.

◆ FlutterVulkanPhysicalDeviceHandle

typedef void* FlutterVulkanPhysicalDeviceHandle

Alias for VkPhysicalDevice.

Definition at line 915 of file embedder.h.

◆ FlutterVulkanPresentCallback

typedef bool(* FlutterVulkanPresentCallback) (void *, const FlutterVulkanImage *)

Callback for when a VkImage has been written to and is ready for use by the embedder.

Definition at line 950 of file embedder.h.

◆ FlutterVulkanQueueHandle

typedef void* FlutterVulkanQueueHandle

Alias for VkQueue.

Definition at line 921 of file embedder.h.

◆ OnPreEngineRestartCallback

typedef void(* OnPreEngineRestartCallback) (void *)

Definition at line 624 of file embedder.h.

◆ ProcResolver

typedef void *(* ProcResolver) (void *, const char *)

Definition at line 617 of file embedder.h.

◆ SoftwareSurfacePresentCallback

typedef bool(* SoftwareSurfacePresentCallback) (void *, const void *, size_t, size_t)

Definition at line 613 of file embedder.h.

◆ TextureFrameCallback

typedef bool(* TextureFrameCallback) (void *, int64_t, size_t, size_t, FlutterOpenGLTexture *)

Definition at line 618 of file embedder.h.

◆ TransformationCallback

typedef FlutterTransformation(* TransformationCallback) (void *)

Definition at line 611 of file embedder.h.

◆ UIntCallback

typedef uint32_t(* UIntCallback) (void *)

Definition at line 612 of file embedder.h.

◆ UIntFrameInfoCallback

typedef uint32_t(* UIntFrameInfoCallback) (void *, const FlutterFrameInfo *)

Callback for when a frame buffer object is requested.

Definition at line 687 of file embedder.h.

◆ VoidCallback

typedef void(* VoidCallback) (void *)

Definition at line 409 of file embedder.h.

◆ VsyncCallback

typedef void(* VsyncCallback) (void *, intptr_t)

Definition at line 623 of file embedder.h.

Enumeration Type Documentation

◆ FlutterAccessibilityFeature

enum FlutterAccessibilityFeature

Additional accessibility features that may be enabled by the platform. Must match the AccessibilityFeatures enum in window.dart.

Enumerator
kFlutterAccessibilityFeatureAccessibleNavigation	Indicate there is a running accessibility service which is changing the interaction model of the device.
kFlutterAccessibilityFeatureInvertColors	Indicate the platform is inverting the colors of the application.
kFlutterAccessibilityFeatureDisableAnimations	Request that animations be disabled or simplified.
kFlutterAccessibilityFeatureBoldText	Request that text be rendered at a bold font weight.
kFlutterAccessibilityFeatureReduceMotion	Request that certain animations be simplified and parallax effects removed.
kFlutterAccessibilityFeatureHighContrast	Request that UI be rendered with darker colors.
kFlutterAccessibilityFeatureOnOffSwitchLabels	Request to show on/off labels inside switches.
kFlutterAccessibilityFeatureNoAnnounce	Indicate the platform does not support announcements.

Definition at line 91 of file embedder.h.

             {
  /// Indicate there is a running accessibility service which is changing the
  /// interaction model of the device.
  kFlutterAccessibilityFeatureAccessibleNavigation = 1 << 0,
  /// Indicate the platform is inverting the colors of the application.
  kFlutterAccessibilityFeatureInvertColors = 1 << 1,
  /// Request that animations be disabled or simplified.
  kFlutterAccessibilityFeatureDisableAnimations = 1 << 2,
  /// Request that text be rendered at a bold font weight.
  kFlutterAccessibilityFeatureBoldText = 1 << 3,
  /// Request that certain animations be simplified and parallax effects
  /// removed.
  kFlutterAccessibilityFeatureReduceMotion = 1 << 4,
  /// Request that UI be rendered with darker colors.
  kFlutterAccessibilityFeatureHighContrast = 1 << 5,
  /// Request to show on/off labels inside switches.
  kFlutterAccessibilityFeatureOnOffSwitchLabels = 1 << 6,
  /// Indicate the platform does not support announcements.
  kFlutterAccessibilityFeatureNoAnnounce = 1 << 7,
} FlutterAccessibilityFeature;

◆ FlutterBackingStoreType

enum FlutterBackingStoreType

Enumerator
kFlutterBackingStoreTypeOpenGL	Specifies an OpenGL backing store. Can either be an OpenGL texture or framebuffer.
kFlutterBackingStoreTypeSoftware	Specified an software allocation for Flutter to render into using the CPU.
kFlutterBackingStoreTypeMetal	Specifies a Metal backing store. This is backed by a Metal texture.
kFlutterBackingStoreTypeVulkan	Specifies a Vulkan backing store. This is backed by a Vulkan VkImage.
kFlutterBackingStoreTypeSoftware2	Specifies a allocation that the engine should render into using software rendering.

Definition at line 2048 of file embedder.h.

             {
  /// Specifies an OpenGL backing store. Can either be an OpenGL texture or
  /// framebuffer.
  kFlutterBackingStoreTypeOpenGL,
  /// Specified an software allocation for Flutter to render into using the CPU.
  kFlutterBackingStoreTypeSoftware,
  /// Specifies a Metal backing store. This is backed by a Metal texture.
  kFlutterBackingStoreTypeMetal,
  /// Specifies a Vulkan backing store. This is backed by a Vulkan VkImage.
  kFlutterBackingStoreTypeVulkan,
  /// Specifies a allocation that the engine should render into using
  /// software rendering.
  kFlutterBackingStoreTypeSoftware2,
} FlutterBackingStoreType;

◆ FlutterCheckState

enum FlutterCheckState

Enumerator
kFlutterCheckStateNone	The semantics node does not have check state.
kFlutterCheckStateTrue	The semantics node is checked.
kFlutterCheckStateFalse	The semantics node is not checked.
kFlutterCheckStateMixed	The semantics node represents a checkbox in mixed state.

Definition at line 280 of file embedder.h.

             {
  /// The semantics node does not have check state.
  kFlutterCheckStateNone,
  /// The semantics node is checked.
  kFlutterCheckStateTrue,
  /// The semantics node is not checked.
  kFlutterCheckStateFalse,
  /// The semantics node represents a checkbox in mixed state.
  kFlutterCheckStateMixed,
} FlutterCheckState;

◆ FlutterEngineAOTDataSourceType

enum FlutterEngineAOTDataSourceType

AOT data source type.

Enumerator
kFlutterEngineAOTDataSourceTypeElfPath

Definition at line 2427 of file embedder.h.

             {
  kFlutterEngineAOTDataSourceTypeElfPath
} FlutterEngineAOTDataSourceType;

◆ FlutterEngineDartObjectType

enum FlutterEngineDartObjectType

Enumerator
kFlutterEngineDartObjectTypeNull
kFlutterEngineDartObjectTypeBool
kFlutterEngineDartObjectTypeInt32
kFlutterEngineDartObjectTypeInt64
kFlutterEngineDartObjectTypeDouble
kFlutterEngineDartObjectTypeString
kFlutterEngineDartObjectTypeBuffer	The object will be made available to Dart code as an instance of Uint8List.

Definition at line 2330 of file embedder.h.

             {
  kFlutterEngineDartObjectTypeNull,
  kFlutterEngineDartObjectTypeBool,
  kFlutterEngineDartObjectTypeInt32,
  kFlutterEngineDartObjectTypeInt64,
  kFlutterEngineDartObjectTypeDouble,
  kFlutterEngineDartObjectTypeString,
  /// The object will be made available to Dart code as an instance of
  /// Uint8List.
  kFlutterEngineDartObjectTypeBuffer,
} FlutterEngineDartObjectType;

◆ FlutterEngineDisplaysUpdateType

enum FlutterEngineDisplaysUpdateType

The update type parameter that is passed to FlutterEngineNotifyDisplayUpdate.

Enumerator

kFlutterEngineDisplaysUpdateTypeStartup

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

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

kFlutterEngineDisplaysUpdateTypeCount

Definition at line 2318 of file embedder.h.

             {
  /// `FlutterEngineDisplay`s 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.
  kFlutterEngineDisplaysUpdateTypeStartup,
  kFlutterEngineDisplaysUpdateTypeCount,
} FlutterEngineDisplaysUpdateType;

◆ FlutterEngineResult

enum FlutterEngineResult

Enumerator
kSuccess
kInvalidLibraryVersion
kInvalidArguments
kInternalInconsistency

Definition at line 72 of file embedder.h.

             {
  kSuccess = 0,
  kInvalidLibraryVersion,
  kInvalidArguments,
  kInternalInconsistency,
} FlutterEngineResult;

◆ FlutterKeyEventDeviceType

enum FlutterKeyEventDeviceType

Enumerator
kFlutterKeyEventDeviceTypeKeyboard
kFlutterKeyEventDeviceTypeDirectionalPad
kFlutterKeyEventDeviceTypeGamepad
kFlutterKeyEventDeviceTypeJoystick
kFlutterKeyEventDeviceTypeHdmi

Definition at line 1352 of file embedder.h.

             {
  kFlutterKeyEventDeviceTypeKeyboard = 1,
  kFlutterKeyEventDeviceTypeDirectionalPad,
  kFlutterKeyEventDeviceTypeGamepad,
  kFlutterKeyEventDeviceTypeJoystick,
  kFlutterKeyEventDeviceTypeHdmi,
} FlutterKeyEventDeviceType;

◆ FlutterKeyEventType

enum FlutterKeyEventType

Enumerator
kFlutterKeyEventTypeUp
kFlutterKeyEventTypeDown
kFlutterKeyEventTypeRepeat

Definition at line 1346 of file embedder.h.

             {
  kFlutterKeyEventTypeUp = 1,
  kFlutterKeyEventTypeDown,
  kFlutterKeyEventTypeRepeat,
} FlutterKeyEventType;

◆ FlutterLayerContentType

enum FlutterLayerContentType

Enumerator
kFlutterLayerContentTypeBackingStore	Indicates that the contents of this layer are rendered by Flutter into a backing store.
kFlutterLayerContentTypePlatformView	Indicates that the contents of this layer are determined by the embedder.

Definition at line 2099 of file embedder.h.

             {
  /// Indicates that the contents of this layer are rendered by Flutter into a
  /// backing store.
  kFlutterLayerContentTypeBackingStore,
  /// Indicates that the contents of this layer are determined by the embedder.
  kFlutterLayerContentTypePlatformView,
} FlutterLayerContentType;

◆ FlutterMetalExternalTexturePixelFormat

enum FlutterMetalExternalTexturePixelFormat

Pixel format for the external texture.

Enumerator
kYUVA
kRGBA

Definition at line 809 of file embedder.h.

             {
  kYUVA,
  kRGBA,
} FlutterMetalExternalTexturePixelFormat;

◆ FlutterMetalExternalTextureYUVColorSpace

enum FlutterMetalExternalTextureYUVColorSpace

YUV color space for the YUV external texture.

Enumerator
kBT601FullRange
kBT601LimitedRange

Definition at line 815 of file embedder.h.

             {
  kBT601FullRange,
  kBT601LimitedRange,
} FlutterMetalExternalTextureYUVColorSpace;

◆ FlutterNativeThreadType

enum FlutterNativeThreadType

This enum allows embedders to determine the type of the engine thread in the FlutterNativeThreadCallback. Based on the thread type, the embedder may be able to tweak the thread priorities for optimum performance.

Enumerator
kFlutterNativeThreadTypePlatform	The Flutter Engine considers the thread on which the FlutterEngineRun call is made to be the platform thread. There is only one such thread per engine instance.
kFlutterNativeThreadTypeRender	This is the thread the Flutter Engine uses to execute rendering commands based on the selected client rendering API. There is only one such thread per engine instance.
kFlutterNativeThreadTypeUI	This is a dedicated thread on which the root Dart isolate is serviced. There is only one such thread per engine instance.
kFlutterNativeThreadTypeWorker	Multiple threads are used by the Flutter engine to perform long running background tasks.

Definition at line 2404 of file embedder.h.

             {
  /// The Flutter Engine considers the thread on which the FlutterEngineRun call
  /// is made to be the platform thread. There is only one such thread per
  /// engine instance.
  kFlutterNativeThreadTypePlatform,
  /// This is the thread the Flutter Engine uses to execute rendering commands
  /// based on the selected client rendering API. There is only one such thread
  /// per engine instance.
  kFlutterNativeThreadTypeRender,
  /// This is a dedicated thread on which the root Dart isolate is serviced.
  /// There is only one such thread per engine instance.
  kFlutterNativeThreadTypeUI,
  /// Multiple threads are used by the Flutter engine to perform long running
  /// background tasks.
  kFlutterNativeThreadTypeWorker,
} FlutterNativeThreadType;

◆ FlutterOpenGLTargetType

enum FlutterOpenGLTargetType

Enumerator
kFlutterOpenGLTargetTypeTexture	Specifies an OpenGL texture target type. Textures are specified using the FlutterOpenGLTexture struct.
kFlutterOpenGLTargetTypeFramebuffer	Specifies an OpenGL frame-buffer target type. Framebuffers are specified using the FlutterOpenGLFramebuffer struct.
kFlutterOpenGLTargetTypeSurface	Specifies an OpenGL on-screen surface target type. Surfaces are specified using the FlutterOpenGLSurface struct.

Definition at line 411 of file embedder.h.

             {
  /// Specifies an OpenGL texture target type. Textures are specified using
  /// the FlutterOpenGLTexture struct.
  kFlutterOpenGLTargetTypeTexture,
  /// Specifies an OpenGL frame-buffer target type. Framebuffers are specified
  /// using the FlutterOpenGLFramebuffer struct.
  kFlutterOpenGLTargetTypeFramebuffer,
  /// Specifies an OpenGL on-screen surface target type. Surfaces are specified
  /// using the FlutterOpenGLSurface struct.
  kFlutterOpenGLTargetTypeSurface,
} FlutterOpenGLTargetType;

◆ FlutterPlatformViewMutationType

enum FlutterPlatformViewMutationType

Enumerator
kFlutterPlatformViewMutationTypeOpacity	Indicates that the Flutter application requested that an opacity be applied to the platform view.
kFlutterPlatformViewMutationTypeClipRect	Indicates that the Flutter application requested that the platform view be clipped using a rectangle.
kFlutterPlatformViewMutationTypeClipRoundedRect	Indicates that the Flutter application requested that the platform view be clipped using a rounded rectangle.
kFlutterPlatformViewMutationTypeTransformation	Indicates that the Flutter application requested that the platform view be transformed before composition.

Definition at line 1997 of file embedder.h.

             {
  /// Indicates that the Flutter application requested that an opacity be
  /// applied to the platform view.
  kFlutterPlatformViewMutationTypeOpacity,
  /// Indicates that the Flutter application requested that the platform view be
  /// clipped using a rectangle.
  kFlutterPlatformViewMutationTypeClipRect,
  /// Indicates that the Flutter application requested that the platform view be
  /// clipped using a rounded rectangle.
  kFlutterPlatformViewMutationTypeClipRoundedRect,
  /// Indicates that the Flutter application requested that the platform view be
  /// transformed before composition.
  kFlutterPlatformViewMutationTypeTransformation,
} FlutterPlatformViewMutationType;

◆ FlutterPointerDeviceKind

enum FlutterPointerDeviceKind

The device type that created a pointer event.

Enumerator
kFlutterPointerDeviceKindMouse
kFlutterPointerDeviceKindTouch
kFlutterPointerDeviceKindStylus
kFlutterPointerDeviceKindTrackpad

Definition at line 1279 of file embedder.h.

             {
  kFlutterPointerDeviceKindMouse = 1,
  kFlutterPointerDeviceKindTouch,
  kFlutterPointerDeviceKindStylus,
  kFlutterPointerDeviceKindTrackpad,
} FlutterPointerDeviceKind;

◆ FlutterPointerMouseButtons

enum FlutterPointerMouseButtons

Flags for the buttons field of FlutterPointerEvent when device_kind is kFlutterPointerDeviceKindMouse.

Enumerator
kFlutterPointerButtonMousePrimary
kFlutterPointerButtonMouseSecondary
kFlutterPointerButtonMouseMiddle
kFlutterPointerButtonMouseBack
kFlutterPointerButtonMouseForward

Definition at line 1288 of file embedder.h.

             {
  kFlutterPointerButtonMousePrimary = 1 << 0,
  kFlutterPointerButtonMouseSecondary = 1 << 1,
  kFlutterPointerButtonMouseMiddle = 1 << 2,
  kFlutterPointerButtonMouseBack = 1 << 3,
  kFlutterPointerButtonMouseForward = 1 << 4,
  /// If a mouse has more than five buttons, send higher bit shifted values
  /// corresponding to the button number: 1 << 5 for the 6th, etc.
} FlutterPointerMouseButtons;

◆ FlutterPointerPhase

enum FlutterPointerPhase

The phase of the pointer event.

Enumerator
kCancel
kUp	The pointer, which must have been down (see kDown), is now up. For touch, this means that the pointer is no longer in contact with the screen. For a mouse, it means the last button was released. Note that if any other buttons are still pressed when one button is released, that should be sent as a kMove rather than a kUp.
kDown	The pointer, which must have been up, is now down. For touch, this means that the pointer has come into contact with the screen. For a mouse, it means a button is now pressed. Note that if any other buttons are already pressed when a new button is pressed, that should be sent as a kMove rather than a kDown.
kMove	The pointer moved while down. This is also used for changes in button state that don't cause a kDown or kUp, such as releasing one of two pressed buttons.
kAdd	The pointer is now sending input to Flutter. For instance, a mouse has entered the area where the Flutter content is displayed. A pointer should always be added before sending any other events.
kRemove	The pointer is no longer sending input to Flutter. For instance, a mouse has left the area where the Flutter content is displayed. A removed pointer should no longer send events until sending a new kAdd.
kHover	The pointer moved while up.
kPanZoomStart	A pan/zoom started on this pointer.
kPanZoomUpdate	The pan/zoom updated.
kPanZoomEnd	The pan/zoom ended.

Definition at line 1237 of file embedder.h.

             {
  kCancel,
  /// The pointer, which must have been down (see kDown), is now up.
  ///
  /// For touch, this means that the pointer is no longer in contact with the
  /// screen. For a mouse, it means the last button was released. Note that if
  /// any other buttons are still pressed when one button is released, that
  /// should be sent as a kMove rather than a kUp.
  kUp,
  /// The pointer, which must have been up, is now down.
  ///
  /// For touch, this means that the pointer has come into contact with the
  /// screen. For a mouse, it means a button is now pressed. Note that if any
  /// other buttons are already pressed when a new button is pressed, that
  /// should be sent as a kMove rather than a kDown.
  kDown,
  /// The pointer moved while down.
  ///
  /// This is also used for changes in button state that don't cause a kDown or
  /// kUp, such as releasing one of two pressed buttons.
  kMove,
  /// The pointer is now sending input to Flutter. For instance, a mouse has
  /// entered the area where the Flutter content is displayed.
  ///
  /// A pointer should always be added before sending any other events.
  kAdd,
  /// The pointer is no longer sending input to Flutter. For instance, a mouse
  /// has left the area where the Flutter content is displayed.
  ///
  /// A removed pointer should no longer send events until sending a new kAdd.
  kRemove,
  /// The pointer moved while up.
  kHover,
  /// A pan/zoom started on this pointer.
  kPanZoomStart,
  /// The pan/zoom updated.
  kPanZoomUpdate,
  /// The pan/zoom ended.
  kPanZoomEnd,
} FlutterPointerPhase;

◆ FlutterPointerSignalKind

enum FlutterPointerSignalKind

The type of a pointer signal.

Enumerator
kFlutterPointerSignalKindNone
kFlutterPointerSignalKindScroll
kFlutterPointerSignalKindScrollInertiaCancel
kFlutterPointerSignalKindScale

Definition at line 1299 of file embedder.h.

             {
  kFlutterPointerSignalKindNone,
  kFlutterPointerSignalKindScroll,
  kFlutterPointerSignalKindScrollInertiaCancel,
  kFlutterPointerSignalKindScale,
} FlutterPointerSignalKind;

◆ FlutterRendererType

enum FlutterRendererType

Enumerator
kOpenGL
kSoftware
kMetal	Metal is only supported on Darwin platforms (macOS / iOS). iOS version >= 10.0 (device), 13.0 (simulator) macOS version >= 10.14
kVulkan

Definition at line 79 of file embedder.h.

             {
  kOpenGL,
  kSoftware,
  /// Metal is only supported on Darwin platforms (macOS / iOS).
  /// iOS version >= 10.0 (device), 13.0 (simulator)
  /// macOS version >= 10.14
  kMetal,
  kVulkan,
} FlutterRendererType;

◆ FlutterSemanticsAction

enum FlutterSemanticsAction

The set of possible actions that can be conveyed to a semantics node.

Must match the SemanticsAction enum in semantics.dart.

Enumerator
kFlutterSemanticsActionTap	The equivalent of a user briefly tapping the screen with the finger without moving it.
kFlutterSemanticsActionLongPress	The equivalent of a user pressing and holding the screen with the finger for a few seconds without moving it.
kFlutterSemanticsActionScrollLeft	The equivalent of a user moving their finger across the screen from right to left.
kFlutterSemanticsActionScrollRight	The equivalent of a user moving their finger across the screen from left to right.
kFlutterSemanticsActionScrollUp	The equivalent of a user moving their finger across the screen from bottom to top.
kFlutterSemanticsActionScrollDown	The equivalent of a user moving their finger across the screen from top to bottom.
kFlutterSemanticsActionIncrease	Increase the value represented by the semantics node.
kFlutterSemanticsActionDecrease	Decrease the value represented by the semantics node.
kFlutterSemanticsActionShowOnScreen	A request to fully show the semantics node on screen.
kFlutterSemanticsActionMoveCursorForwardByCharacter	Move the cursor forward by one character.
kFlutterSemanticsActionMoveCursorBackwardByCharacter	Move the cursor backward by one character.
kFlutterSemanticsActionSetSelection	Set the text selection to the given range.
kFlutterSemanticsActionCopy	Copy the current selection to the clipboard.
kFlutterSemanticsActionCut	Cut the current selection and place it in the clipboard.
kFlutterSemanticsActionPaste	Paste the current content of the clipboard.
kFlutterSemanticsActionDidGainAccessibilityFocus	Indicate that the node has gained accessibility focus.
kFlutterSemanticsActionDidLoseAccessibilityFocus	Indicate that the node has lost accessibility focus.
kFlutterSemanticsActionCustomAction	Indicate that the user has invoked a custom accessibility action.
kFlutterSemanticsActionDismiss	A request that the node should be dismissed.
kFlutterSemanticsActionMoveCursorForwardByWord	Move the cursor forward by one word.
kFlutterSemanticsActionMoveCursorBackwardByWord	Move the cursor backward by one word.
kFlutterSemanticsActionSetText	Replace the current text in the text field.
kFlutterSemanticsActionFocus	Request that the respective focusable widget gain input focus.
kFlutterSemanticsActionScrollToOffset	Request that scrolls the current scrollable container to a given scroll offset.
kFlutterSemanticsActionExpand	A request that the node should be expanded.
kFlutterSemanticsActionCollapse	A request that the node should be collapsed.

Definition at line 115 of file embedder.h.

             {
  /// The equivalent of a user briefly tapping the screen with the finger
  /// without moving it.
  kFlutterSemanticsActionTap = 1 << 0,
  /// The equivalent of a user pressing and holding the screen with the finger
  /// for a few seconds without moving it.
  kFlutterSemanticsActionLongPress = 1 << 1,
  /// The equivalent of a user moving their finger across the screen from right
  /// to left.
  kFlutterSemanticsActionScrollLeft = 1 << 2,
  /// The equivalent of a user moving their finger across the screen from left
  /// to
  /// right.
  kFlutterSemanticsActionScrollRight = 1 << 3,
  /// The equivalent of a user moving their finger across the screen from bottom
  /// to top.
  kFlutterSemanticsActionScrollUp = 1 << 4,
  /// The equivalent of a user moving their finger across the screen from top to
  /// bottom.
  kFlutterSemanticsActionScrollDown = 1 << 5,
  /// Increase the value represented by the semantics node.
  kFlutterSemanticsActionIncrease = 1 << 6,
  /// Decrease the value represented by the semantics node.
  kFlutterSemanticsActionDecrease = 1 << 7,
  /// A request to fully show the semantics node on screen.
  kFlutterSemanticsActionShowOnScreen = 1 << 8,
  /// Move the cursor forward by one character.
  kFlutterSemanticsActionMoveCursorForwardByCharacter = 1 << 9,
  /// Move the cursor backward by one character.
  kFlutterSemanticsActionMoveCursorBackwardByCharacter = 1 << 10,
  /// Set the text selection to the given range.
  kFlutterSemanticsActionSetSelection = 1 << 11,
  /// Copy the current selection to the clipboard.
  kFlutterSemanticsActionCopy = 1 << 12,
  /// Cut the current selection and place it in the clipboard.
  kFlutterSemanticsActionCut = 1 << 13,
  /// Paste the current content of the clipboard.
  kFlutterSemanticsActionPaste = 1 << 14,
  /// Indicate that the node has gained accessibility focus.
  kFlutterSemanticsActionDidGainAccessibilityFocus = 1 << 15,
  /// Indicate that the node has lost accessibility focus.
  kFlutterSemanticsActionDidLoseAccessibilityFocus = 1 << 16,
  /// Indicate that the user has invoked a custom accessibility action.
  kFlutterSemanticsActionCustomAction = 1 << 17,
  /// A request that the node should be dismissed.
  kFlutterSemanticsActionDismiss = 1 << 18,
  /// Move the cursor forward by one word.
  kFlutterSemanticsActionMoveCursorForwardByWord = 1 << 19,
  /// Move the cursor backward by one word.
  kFlutterSemanticsActionMoveCursorBackwardByWord = 1 << 20,
  /// Replace the current text in the text field.
  kFlutterSemanticsActionSetText = 1 << 21,
  /// Request that the respective focusable widget gain input focus.
  kFlutterSemanticsActionFocus = 1 << 22,
  /// Request that scrolls the current scrollable container to a given scroll
  /// offset.
  kFlutterSemanticsActionScrollToOffset = 1 << 23,
  /// A request that the node should be expanded.
  kFlutterSemanticsActionExpand = 1 << 24,
  /// A request that the node should be collapsed.
  kFlutterSemanticsActionCollapse = 1 << 25,
} FlutterSemanticsAction;

◆ FlutterSemanticsFlag

enum FlutterSemanticsFlag

The set of properties that may be associated with a semantics node.

Must match the SemanticsFlag enum in semantics.dart.

Enumerator
kFlutterSemanticsFlagHasCheckedState	The semantics node has the quality of either being "checked" or "unchecked".
kFlutterSemanticsFlagIsChecked	Whether a semantics node is checked.
kFlutterSemanticsFlagIsSelected	Whether a semantics node is selected.
kFlutterSemanticsFlagIsButton	Whether the semantic node represents a button.
kFlutterSemanticsFlagIsTextField	Whether the semantic node represents a text field.
kFlutterSemanticsFlagIsFocused	Whether the semantic node currently holds the user's focus.
kFlutterSemanticsFlagHasEnabledState	The semantics node has the quality of either being "enabled" or "disabled".
kFlutterSemanticsFlagIsEnabled	Whether a semantic node that hasEnabledState is currently enabled.
kFlutterSemanticsFlagIsInMutuallyExclusiveGroup	Whether a semantic node is in a mutually exclusive group.
kFlutterSemanticsFlagIsHeader	Whether a semantic node is a header that divides content into sections.
kFlutterSemanticsFlagIsObscured	Whether the value of the semantics node is obscured.
kFlutterSemanticsFlagScopesRoute	Whether the semantics node is the root of a subtree for which a route name should be announced.
kFlutterSemanticsFlagNamesRoute	Whether the semantics node label is the name of a visually distinct route.
kFlutterSemanticsFlagIsHidden	Whether the semantics node is considered hidden.
kFlutterSemanticsFlagIsImage	Whether the semantics node represents an image.
kFlutterSemanticsFlagIsLiveRegion	Whether the semantics node is a live region.
kFlutterSemanticsFlagHasToggledState	The semantics node has the quality of either being "on" or "off".
kFlutterSemanticsFlagIsToggled	If true, the semantics node is "on". If false, the semantics node is "off".
kFlutterSemanticsFlagHasImplicitScrolling	Whether the platform can scroll the semantics node when the user attempts to move the accessibility focus to an offscreen child. For example, a `ListView` widget has implicit scrolling so that users can easily move the accessibility focus to the next set of children. A `PageView` widget does not have implicit scrolling, so that users don't navigate to the next page when reaching the end of the current one.
kFlutterSemanticsFlagIsMultiline	Whether the value of the semantics node is coming from a multi-line text field. This is used for text fields to distinguish single-line text fields from multi-line ones.
kFlutterSemanticsFlagIsReadOnly	Whether the semantic node is read only. Only applicable when kFlutterSemanticsFlagIsTextField flag is on.
kFlutterSemanticsFlagIsFocusable	Whether the semantic node can hold the user's focus.
kFlutterSemanticsFlagIsLink	Whether the semantics node represents a link.
kFlutterSemanticsFlagIsSlider	Whether the semantics node represents a slider.
kFlutterSemanticsFlagIsKeyboardKey	Whether the semantics node represents a keyboard key.
kFlutterSemanticsFlagIsCheckStateMixed	Whether the semantics node represents a tristate checkbox in mixed state.
kFlutterSemanticsFlagHasExpandedState	The semantics node has the quality of either being "expanded" or "collapsed".
kFlutterSemanticsFlagIsExpanded	Whether a semantic node that hasExpandedState is currently expanded.
kFlutterSemanticsFlagHasSelectedState	The semantics node has the quality of either being "selected" or "not selected".
kFlutterSemanticsFlagHasRequiredState	Whether a semantics node has the quality of being required.
kFlutterSemanticsFlagIsRequired	Whether user input is required on the semantics node before a form can be submitted. Only applicable when kFlutterSemanticsFlagHasRequiredState flag is on.

Definition at line 185 of file embedder.h.

             {
  /// The semantics node has the quality of either being "checked" or
  /// "unchecked".
  kFlutterSemanticsFlagHasCheckedState = 1 << 0,
  /// Whether a semantics node is checked.
  kFlutterSemanticsFlagIsChecked = 1 << 1,
  /// Whether a semantics node is selected.
  kFlutterSemanticsFlagIsSelected = 1 << 2,
  /// Whether the semantic node represents a button.
  kFlutterSemanticsFlagIsButton = 1 << 3,
  /// Whether the semantic node represents a text field.
  kFlutterSemanticsFlagIsTextField = 1 << 4,
  /// Whether the semantic node currently holds the user's focus.
  kFlutterSemanticsFlagIsFocused = 1 << 5,
  /// The semantics node has the quality of either being "enabled" or
  /// "disabled".
  kFlutterSemanticsFlagHasEnabledState = 1 << 6,
  /// Whether a semantic node that hasEnabledState is currently enabled.
  kFlutterSemanticsFlagIsEnabled = 1 << 7,
  /// Whether a semantic node is in a mutually exclusive group.
  kFlutterSemanticsFlagIsInMutuallyExclusiveGroup = 1 << 8,
  /// Whether a semantic node is a header that divides content into sections.
  kFlutterSemanticsFlagIsHeader = 1 << 9,
  /// Whether the value of the semantics node is obscured.
  kFlutterSemanticsFlagIsObscured = 1 << 10,
  /// Whether the semantics node is the root of a subtree for which a route name
  /// should be announced.
  kFlutterSemanticsFlagScopesRoute = 1 << 11,
  /// Whether the semantics node label is the name of a visually distinct route.
  kFlutterSemanticsFlagNamesRoute = 1 << 12,
  /// Whether the semantics node is considered hidden.
  kFlutterSemanticsFlagIsHidden = 1 << 13,
  /// Whether the semantics node represents an image.
  kFlutterSemanticsFlagIsImage = 1 << 14,
  /// Whether the semantics node is a live region.
  kFlutterSemanticsFlagIsLiveRegion = 1 << 15,
  /// The semantics node has the quality of either being "on" or "off".
  kFlutterSemanticsFlagHasToggledState = 1 << 16,
  /// If true, the semantics node is "on". If false, the semantics node is
  /// "off".
  kFlutterSemanticsFlagIsToggled = 1 << 17,
  /// Whether the platform can scroll the semantics node when the user attempts
  /// to move the accessibility focus to an offscreen child.
  ///
  /// For example, a `ListView` widget has implicit scrolling so that users can
  /// easily move the accessibility focus to the next set of children. A
  /// `PageView` widget does not have implicit scrolling, so that users don't
  /// navigate to the next page when reaching the end of the current one.
  kFlutterSemanticsFlagHasImplicitScrolling = 1 << 18,
  /// Whether the value of the semantics node is coming from a multi-line text
  /// field.
  ///
  /// This is used for text fields to distinguish single-line text fields from
  /// multi-line ones.
  kFlutterSemanticsFlagIsMultiline = 1 << 19,
  /// Whether the semantic node is read only.
  ///
  /// Only applicable when kFlutterSemanticsFlagIsTextField flag is on.
  kFlutterSemanticsFlagIsReadOnly = 1 << 20,
  /// Whether the semantic node can hold the user's focus.
  kFlutterSemanticsFlagIsFocusable = 1 << 21,
  /// Whether the semantics node represents a link.
  kFlutterSemanticsFlagIsLink = 1 << 22,
  /// Whether the semantics node represents a slider.
  kFlutterSemanticsFlagIsSlider = 1 << 23,
  /// Whether the semantics node represents a keyboard key.
  kFlutterSemanticsFlagIsKeyboardKey = 1 << 24,
  /// Whether the semantics node represents a tristate checkbox in mixed state.
  kFlutterSemanticsFlagIsCheckStateMixed = 1 << 25,
  /// The semantics node has the quality of either being "expanded" or
  /// "collapsed".
  kFlutterSemanticsFlagHasExpandedState = 1 << 26,
  /// Whether a semantic node that hasExpandedState is currently expanded.
  kFlutterSemanticsFlagIsExpanded = 1 << 27,
  /// The semantics node has the quality of either being "selected" or
  /// "not selected".
  kFlutterSemanticsFlagHasSelectedState = 1 << 28,
  /// Whether a semantics node has the quality of being required.
  kFlutterSemanticsFlagHasRequiredState = 1 << 29,
  /// Whether user input is required on the semantics node before a form can be
  /// submitted.
  ///
  /// Only applicable when kFlutterSemanticsFlagHasRequiredState flag is on.
  kFlutterSemanticsFlagIsRequired = 1 << 30,
} FlutterSemanticsFlag;

◆ FlutterSoftwarePixelFormat

enum FlutterSoftwarePixelFormat

A pixel format to be used for software rendering.

A single pixel always stored as a POT number of bytes. (so in practice either 1, 2, 4, 8, 16 bytes per pixel)

There are two kinds of pixel formats:

formats where all components are 8 bits, called array formats The component order as specified in the pixel format name is the order of the components' bytes in memory, with the leftmost component occupying the lowest memory address.
all other formats are called packed formats, and the component order as specified in the format name refers to the order from most significant to least significant bits in the native type. for example, for kFlutterSoftwarePixelFormatRGB565, R occupies the 5 most significant bits, G the middle 6 bits, and B the 5 least significant bits.

Each pixel format in this list is documented with an example on how to get the color components from the pixel.

for packed formats, p is the pixel value as a word. For example, you can get the pixel value for a RGB565 formatted buffer like this: uint16_t p = ((const uint16_t*) allocation)[row_bytes * y / bpp + x]; (with bpp being the bytes per pixel, so 2 for RGB565)
for array formats, p is a pointer to the pixel value. For example, you can get the p for a RGBA8888 formatted buffer like this: const uint8_t p = ((const uint8_t) allocation) + row_bytes*y + x*4;

Enumerator
kFlutterSoftwarePixelFormatGray8	Pixel with 8 bit grayscale value. The grayscale value is the luma value calculated from r, g, b according to BT.709. (gray = r0.2126 + g0.7152 + b*0.0722)
kFlutterSoftwarePixelFormatRGB565	Pixel with 5 bits red, 6 bits green, 5 bits blue, in 16-bit word. r = (p >> 11) & 0x1F; g = (p >> 5) & 0x3F; b = p & 0x1F; On most (== little-endian) systems, this is equivalent to wayland format RGB565 (WL_DRM_FORMAT_RGB565, WL_SHM_FORMAT_RGB565).
kFlutterSoftwarePixelFormatRGBA4444	Pixel with 4 bits each for alpha, red, green, blue; in 16-bit word. r = (p >> 8) & 0xF; g = (p >> 4) & 0xF; b = p & 0xF; a = (p >> 12) & 0xF; On most (== little-endian) systems, this is equivalent to wayland format RGBA4444 (WL_DRM_FORMAT_RGBA4444, WL_SHM_FORMAT_RGBA4444).
kFlutterSoftwarePixelFormatRGBA8888	Pixel with 8 bits each for red, green, blue, alpha. r = p[0]; g = p[1]; b = p[2]; a = p[3]; This is equivalent to wayland format ABGR8888 (WL_DRM_FORMAT_ABGR8888, WL_SHM_FORMAT_ABGR8888).
kFlutterSoftwarePixelFormatRGBX8888	Pixel with 8 bits each for red, green and blue and 8 unused bits. r = p[0]; g = p[1]; b = p[2]; This is equivalent to wayland format XBGR8888 (WL_DRM_FORMAT_XBGR8888, WL_SHM_FORMAT_XBGR8888).
kFlutterSoftwarePixelFormatBGRA8888	Pixel with 8 bits each for blue, green, red and alpha. r = p[2]; g = p[1]; b = p[0]; a = p[3]; This is equivalent to wayland format ARGB8888 (WL_DRM_FORMAT_ARGB8888, WL_SHM_FORMAT_ARGB8888).
kFlutterSoftwarePixelFormatNative32	Either kFlutterSoftwarePixelFormatBGRA8888 or kFlutterSoftwarePixelFormatRGBA8888 depending on CPU endianess and OS.

Definition at line 450 of file embedder.h.

             {
  /// Pixel with 8 bit grayscale value.
  /// The grayscale value is the luma value calculated from r, g, b
  /// according to BT.709. (gray = r*0.2126 + g*0.7152 + b*0.0722)
  kFlutterSoftwarePixelFormatGray8,
 
  /// Pixel with 5 bits red, 6 bits green, 5 bits blue, in 16-bit word.
  ///   r = (p >> 11) & 0x1F;
  ///   g = (p >> 5) & 0x3F;
  ///   b = p & 0x1F;
  ///
  /// On most (== little-endian) systems, this is equivalent to wayland format
  /// RGB565 (WL_DRM_FORMAT_RGB565, WL_SHM_FORMAT_RGB565).
  kFlutterSoftwarePixelFormatRGB565,
 
  /// Pixel with 4 bits each for alpha, red, green, blue; in 16-bit word.
  ///   r = (p >> 8) & 0xF;
  ///   g = (p >> 4) & 0xF;
  ///   b = p & 0xF;
  ///   a = (p >> 12) & 0xF;
  ///
  /// On most (== little-endian) systems, this is equivalent to wayland format
  /// RGBA4444 (WL_DRM_FORMAT_RGBA4444, WL_SHM_FORMAT_RGBA4444).
  kFlutterSoftwarePixelFormatRGBA4444,
 
  /// Pixel with 8 bits each for red, green, blue, alpha.
  ///   r = p[0];
  ///   g = p[1];
  ///   b = p[2];
  ///   a = p[3];
  ///
  /// This is equivalent to wayland format ABGR8888 (WL_DRM_FORMAT_ABGR8888,
  /// WL_SHM_FORMAT_ABGR8888).
  kFlutterSoftwarePixelFormatRGBA8888,
 
  /// Pixel with 8 bits each for red, green and blue and 8 unused bits.
  ///   r = p[0];
  ///   g = p[1];
  ///   b = p[2];
  ///
  /// This is equivalent to wayland format XBGR8888 (WL_DRM_FORMAT_XBGR8888,
  /// WL_SHM_FORMAT_XBGR8888).
  kFlutterSoftwarePixelFormatRGBX8888,
 
  /// Pixel with 8 bits each for blue, green, red and alpha.
  ///   r = p[2];
  ///   g = p[1];
  ///   b = p[0];
  ///   a = p[3];
  ///
  /// This is equivalent to wayland format ARGB8888 (WL_DRM_FORMAT_ARGB8888,
  /// WL_SHM_FORMAT_ARGB8888).
  kFlutterSoftwarePixelFormatBGRA8888,
 
  /// Either kFlutterSoftwarePixelFormatBGRA8888 or
  /// kFlutterSoftwarePixelFormatRGBA8888 depending on CPU endianess and OS.
  kFlutterSoftwarePixelFormatNative32,
} FlutterSoftwarePixelFormat;

◆ FlutterStringAttributeType

enum FlutterStringAttributeType

Enumerator
kSpellOut
kLocale

Definition at line 1472 of file embedder.h.

             {
  // Indicates the string should be announced character by character.
  kSpellOut,
  // Indicates the string should be announced using the specified locale.
  kLocale,
} FlutterStringAttributeType;

◆ FlutterTextDirection

enum FlutterTextDirection

Enumerator
kFlutterTextDirectionUnknown	Text has unknown text direction.
kFlutterTextDirectionRTL	Text is read from right to left.
kFlutterTextDirectionLTR	Text is read from left to right.

Definition at line 359 of file embedder.h.

             {
  /// Text has unknown text direction.
  kFlutterTextDirectionUnknown = 0,
  /// Text is read from right to left.
  kFlutterTextDirectionRTL = 1,
  /// Text is read from left to right.
  kFlutterTextDirectionLTR = 2,
} FlutterTextDirection;

◆ FlutterThreadPriority

enum FlutterThreadPriority

Valid values for priority of Thread.

Enumerator
kBackground	Suitable for threads that shouldn't disrupt high priority work.
kNormal	Default priority level.
kDisplay	Suitable for threads which generate data for the display.
kRaster	Suitable for thread which raster data.

Definition at line 369 of file embedder.h.

             {
  /// Suitable for threads that shouldn't disrupt high priority work.
  kBackground = 0,
  /// Default priority level.
  kNormal = 1,
  /// Suitable for threads which generate data for the display.
  kDisplay = 2,
  /// Suitable for thread which raster data.
  kRaster = 3,
} FlutterThreadPriority;

◆ FlutterTristate

enum FlutterTristate

Enumerator
kFlutterTristateNone	The property is not applicable to this semantics node.
kFlutterTristateTrue	The property is applicable and its state is "true" or "on".
kFlutterTristateFalse	The property is applicable and its state is "false" or "off".

Definition at line 271 of file embedder.h.

             {
  /// The property is not applicable to this semantics node.
  kFlutterTristateNone,
  /// The property is applicable and its state is "true" or "on".
  kFlutterTristateTrue,
  /// The property is applicable and its state is "false" or "off".
  kFlutterTristateFalse,
} FlutterTristate;

◆ FlutterViewFocusDirection

enum FlutterViewFocusDirection

Represents the direction in which the focus transitioned across [FlutterView]s.

Enumerator

kUndefined

Indicates the focus transition did not have a direction.

This is typically associated with focus being programmatically requested or when focus is lost.

kForward

Indicates the focus transition was performed in a forward direction.

This is typically result of the user pressing tab.

kBackward

Indicates the focus transition was performed in a backward direction.

This is typically result of the user pressing shift + tab.

Definition at line 1170 of file embedder.h.

             {
  /// Indicates the focus transition did not have a direction.
  ///
  /// This is typically associated with focus being programmatically requested
  /// or when focus is lost.
  kUndefined,
 
  /// Indicates the focus transition was performed in a forward direction.
  ///
  /// This is typically result of the user pressing tab.
  kForward,
 
  /// Indicates the focus transition was performed in a backward direction.
  ///
  /// This is typically result of the user pressing shift + tab.
  kBackward,
} FlutterViewFocusDirection;

◆ FlutterViewFocusState

enum FlutterViewFocusState

Represents the focus state of a given [FlutterView].

Enumerator
kUnfocused	Specifies that a view does not have platform focus.
kFocused	Specifies that a view has platform focus.

Definition at line 1189 of file embedder.h.

             {
  /// Specifies that a view does not have platform focus.
  kUnfocused,
 
  /// Specifies that a view has platform focus.
  kFocused,
} FlutterViewFocusState;

Function Documentation

◆ __FlutterEngineFlushPendingTasksNow()

FLUTTER_EXPORT FlutterEngineResult __FlutterEngineFlushPendingTasksNow ( )

This API is only meant to be used by platforms that need to flush tasks on a message loop not controlled by the Flutter engine.

Returns: The result of the call.

Definition at line 3105 of file embedder.cc.

                                                          {
  fml::MessageLoop::GetCurrent().RunExpiredTasksNow();
  return kSuccess;
}

References fml::MessageLoop::GetCurrent(), kSuccess, and fml::MessageLoop::RunExpiredTasksNow().

◆ FlutterEngineAddView()

FLUTTER_EXPORT FlutterEngineResult FlutterEngineAddView	(	FLUTTER_API_SYMBOL(FlutterEngine)	engine,
		const FlutterAddViewInfo *	info
	)

Adds a view.

        This is an asynchronous operation. The view should not be used
        until the |info.add_view_callback| is invoked with an |added|
        value of true. The embedder should prepare resources in advance
        but be ready to clean up on failure.

        A frame is scheduled if the operation succeeds.

        The callback is invoked on a thread managed by the engine. The
        embedder should re-thread if needed.

        Attempting to add the implicit view will fail and will return
        kInvalidArguments. Attempting to add a view with an already
        existing view ID will fail, and |info.add_view_callback| will be
        invoked with an |added| value of false.

Parameters

[in]	engine	A running engine instance.
[in]	info	The add view arguments. This can be deallocated once \|FlutterEngineAddView\| returns, before \|add_view_callback\| is invoked.

Returns: The result of starting the asynchronous operation. If kSuccess, the |add_view_callback| will be invoked.

Definition at line 2500 of file embedder.cc.

                                                                         {
  if (!engine) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Engine handle was invalid.");
  }
  if (!info || !info->view_metrics || !info->add_view_callback) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments,
                              "Add view info handle was invalid.");
  }
 
  FlutterViewId view_id = info->view_id;
  if (view_id == kFlutterImplicitViewId) {
    return LOG_EMBEDDER_ERROR(
        kInvalidArguments,
        "Add view info was invalid. The implicit view cannot be added.");
  }
  if (SAFE_ACCESS(info->view_metrics, view_id, kFlutterImplicitViewId) !=
      view_id) {
    if (view_id == kFlutterImplicitViewId) {
      return LOG_EMBEDDER_ERROR(kInvalidArguments,
                                "Add view info was invalid. The info and "
                                "window metric view IDs must match.");
    }
  }
 
  // TODO(loicsharma): Return an error if the engine was initialized with
  // callbacks that are incompatible with multiple views.
  // https://github.com/flutter/flutter/issues/144806
 
  std::variant<flutter::ViewportMetrics, std::string> metrics_or_error =
      MakeViewportMetricsFromWindowMetrics(info->view_metrics);
 
  if (const std::string* error = std::get_if<std::string>(&metrics_or_error)) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, error->c_str());
  }
 
  auto metrics = std::get<flutter::ViewportMetrics>(metrics_or_error);
 
  // The engine must be running to add a view.
  auto embedder_engine = reinterpret_cast<flutter::EmbedderEngine*>(engine);
  if (!embedder_engine->IsValid()) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Engine handle was invalid.");
  }
 
  flutter::PlatformView::AddViewCallback callback =
      [c_callback = info->add_view_callback,
       user_data = info->user_data](bool added) {
        FlutterAddViewResult result = {};
        result.struct_size = sizeof(FlutterAddViewResult);
        result.added = added;
        result.user_data = user_data;
        c_callback(&result);
      };
 
  embedder_engine->GetShell().GetPlatformView()->AddView(view_id, metrics,
                                                         callback);
  return kSuccess;
}

References FlutterAddViewInfo::add_view_callback, FlutterAddViewResult::added, callback, engine, error, kFlutterImplicitViewId, kInvalidArguments, kSuccess, LOG_EMBEDDER_ERROR, MakeViewportMetricsFromWindowMetrics(), SAFE_ACCESS, FlutterAddViewResult::struct_size, user_data, FlutterAddViewResult::user_data, FlutterAddViewInfo::user_data, FlutterAddViewInfo::view_id, view_id, and FlutterAddViewInfo::view_metrics.

Referenced by FlutterEngineGetProcAddresses(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

◆ FlutterEngineCollectAOTData()

FLUTTER_EXPORT FlutterEngineResult FlutterEngineCollectAOTData ( FlutterEngineAOTData data )

Collects the AOT data.

Warning: The embedder must ensure that this call is made only after all FlutterEngine instances launched using this data have been terminated, and that all of those instances were launched with the FlutterProjectArgs::shutdown_dart_vm_when_done flag set to true.

Parameters

[in] data The data to collect.

Returns: Returns if the AOT data was successfully collected.

Definition at line 1736 of file embedder.cc.

                                                                           {
  if (!data) {
    // Deleting a null object should be a no-op.
    return kSuccess;
  }
 
  // Created in a unique pointer in `FlutterEngineCreateAOTData`.
  delete data;
  return kSuccess;
}

References data, and kSuccess.

Referenced by FlutterEngineGetProcAddresses(), flutter::testing::AOTDataDeleter::operator()(), AOTDataDeleter::operator()(), and flutter::testing::TEST_F().

◆ FlutterEngineCreateAOTData()

FLUTTER_EXPORT FlutterEngineResult FlutterEngineCreateAOTData	(	const FlutterEngineAOTDataSource *	source,
		FlutterEngineAOTData *	data_out
	)

Creates the necessary data structures to launch a Flutter Dart application in AOT mode. The data may only be collected after all FlutterEngine instances launched using this data have been terminated.

Parameters

[in]	source	The source of the AOT data.
[out]	data_out	The AOT data on success. Unchanged on failure.

Returns: Returns if the AOT data could be successfully resolved.

Definition at line 1682 of file embedder.cc.

                                    {
  if (!flutter::DartVM::IsRunningPrecompiledCode()) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments,
                              "AOT data can only be created in AOT mode.");
  } else if (!source) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Null source specified.");
  } else if (!data_out) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Null data_out specified.");
  }
 
  switch (source->type) {
    case kFlutterEngineAOTDataSourceTypeElfPath: {
      if (!source->elf_path || !fml::IsFile(source->elf_path)) {
        return LOG_EMBEDDER_ERROR(kInvalidArguments,
                                  "Invalid ELF path specified.");
      }
 
      auto aot_data = std::make_unique<_FlutterEngineAOTData>();
      const char* error = nullptr;
 
#if OS_FUCHSIA
      // TODO(gw280): https://github.com/flutter/flutter/issues/50285
      // Dart doesn't implement Dart_LoadELF on Fuchsia
      Dart_LoadedElf* loaded_elf = nullptr;
#else
      Dart_LoadedElf* loaded_elf = Dart_LoadELF(
          source->elf_path,               // file path
          0,                              // file offset
          &error,                         // error (out)
          &aot_data->vm_snapshot_data,    // vm snapshot data (out)
          &aot_data->vm_snapshot_instrs,  // vm snapshot instr (out)
          &aot_data->vm_isolate_data,     // vm isolate data (out)
          &aot_data->vm_isolate_instrs    // vm isolate instr (out)
      );
#endif
 
      if (loaded_elf == nullptr) {
        return LOG_EMBEDDER_ERROR(kInvalidArguments, error);
      }
 
      aot_data->loaded_elf.reset(loaded_elf);
 
      *data_out = aot_data.release();
      return kSuccess;
    }
  }
 
  return LOG_EMBEDDER_ERROR(
      kInvalidArguments,
      "Invalid FlutterEngineAOTDataSourceType type specified.");
}

References FlutterEngineAOTDataSource::elf_path, error, fml::IsFile(), flutter::DartVM::IsRunningPrecompiledCode(), kFlutterEngineAOTDataSourceTypeElfPath, kInvalidArguments, kSuccess, LOG_EMBEDDER_ERROR, and FlutterEngineAOTDataSource::type.

Referenced by FlutterEngineGetProcAddresses(), LoadAotData(), flutter::testing::EmbedderTestContext::SetupAOTDataIfNecessary(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

◆ FlutterEngineDeinitialize()

FLUTTER_EXPORT FlutterEngineResult FlutterEngineDeinitialize ( FLUTTER_API_SYMBOL(FlutterEngine) engine )

Stops running the Flutter engine instance. After this call, the embedder is also guaranteed that no more calls to post tasks onto custom task runners specified by the embedder are made. The Flutter engine handle still needs to be collected via a call to FlutterEngineShutdown.

Parameters

[in] engine The running engine instance to de-initialize.

Returns: The result of the call to de-initialize the Flutter engine.

Definition at line 2636 of file embedder.cc.

                                                          {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Engine handle was invalid.");
  }
 
  auto embedder_engine = reinterpret_cast<flutter::EmbedderEngine*>(engine);
  embedder_engine->NotifyDestroyed();
  embedder_engine->CollectShell();
  embedder_engine->CollectThreadHost();
  return kSuccess;
}

References engine, kInvalidArguments, kSuccess, LOG_EMBEDDER_ERROR, and flutter::EmbedderEngine::NotifyDestroyed().

Referenced by FlutterEngineGetProcAddresses(), FlutterEngineShutdown(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), and flutter::testing::TEST_P().

◆ FlutterEngineDispatchSemanticsAction()

FLUTTER_EXPORT FlutterEngineResult FlutterEngineDispatchSemanticsAction	(	FLUTTER_API_SYMBOL(FlutterEngine)	engine,
		uint64_t	node_id,
		FlutterSemanticsAction	action,
		const uint8_t *	data,
		size_t	data_length
	)

Dispatch a semantics action to the specified semantics node in the implicit view.

Parameters

[in]	engine	A running engine instance.
[in]	node_id	The semantics node identifier.
[in]	action	The semantics action.
[in]	data	Data associated with the action.
[in]	data_length	The data length.

Returns: The result of the call.

Definition at line 3196 of file embedder.cc.

                        {
  FlutterSendSemanticsActionInfo info{
      .struct_size = sizeof(FlutterSendSemanticsActionInfo),
      .view_id = kFlutterImplicitViewId,
      .node_id = node_id,
      .action = action,
      .data = data,
      .data_length = data_length};
  return FlutterEngineSendSemanticsAction(engine, &info);
}

References action, data, engine, FlutterEngineSendSemanticsAction(), kFlutterImplicitViewId, FlutterSendSemanticsActionInfo::struct_size, and view_id.

Referenced by FlutterEngineGetProcAddresses(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

◆ FlutterEngineGetCurrentTime()

FLUTTER_EXPORT uint64_t FlutterEngineGetCurrentTime ( )

Get the current time in nanoseconds from the clock used by the flutter engine. This is the system monotonic clock.

Returns: The current time in nanoseconds.

Definition at line 3309 of file embedder.cc.

                                       {
  return fml::TimePoint::Now().ToEpochDelta().ToNanoseconds();
}

References fml::TimePoint::Now(), fml::TimePoint::ToEpochDelta(), and fml::TimeDelta::ToNanoseconds().

Referenced by FlutterEngineGetProcAddresses(), flutter::testing::TEST(), and flutter::EventLoop::TimePointFromFlutterTime().

◆ FlutterEngineGetProcAddresses()

FLUTTER_EXPORT FlutterEngineResult FlutterEngineGetProcAddresses ( FlutterEngineProcTable * table )

Gets the table of engine function pointers.

Parameters

[out] table The table to fill with pointers. This should be zero-initialized, except for struct_size.

Returns: Returns whether the table was successfully populated.

Definition at line 3696 of file embedder.cc.

                                   {
  if (!table) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Null table specified.");
  }
#define SET_PROC(member, function)        \
  if (STRUCT_HAS_MEMBER(table, member)) { \
    table->member = &function;            \
  }
 
  SET_PROC(CreateAOTData, FlutterEngineCreateAOTData);
  SET_PROC(CollectAOTData, FlutterEngineCollectAOTData);
  SET_PROC(Run, FlutterEngineRun);
  SET_PROC(Shutdown, FlutterEngineShutdown);
  SET_PROC(Initialize, FlutterEngineInitialize);
  SET_PROC(Deinitialize, FlutterEngineDeinitialize);
  SET_PROC(RunInitialized, FlutterEngineRunInitialized);
  SET_PROC(SendWindowMetricsEvent, FlutterEngineSendWindowMetricsEvent);
  SET_PROC(SendPointerEvent, FlutterEngineSendPointerEvent);
  SET_PROC(SendKeyEvent, FlutterEngineSendKeyEvent);
  SET_PROC(SendPlatformMessage, FlutterEngineSendPlatformMessage);
  SET_PROC(PlatformMessageCreateResponseHandle,
           FlutterPlatformMessageCreateResponseHandle);
  SET_PROC(PlatformMessageReleaseResponseHandle,
           FlutterPlatformMessageReleaseResponseHandle);
  SET_PROC(SendPlatformMessageResponse,
           FlutterEngineSendPlatformMessageResponse);
  SET_PROC(RegisterExternalTexture, FlutterEngineRegisterExternalTexture);
  SET_PROC(UnregisterExternalTexture, FlutterEngineUnregisterExternalTexture);
  SET_PROC(MarkExternalTextureFrameAvailable,
           FlutterEngineMarkExternalTextureFrameAvailable);
  SET_PROC(UpdateSemanticsEnabled, FlutterEngineUpdateSemanticsEnabled);
  SET_PROC(UpdateAccessibilityFeatures,
           FlutterEngineUpdateAccessibilityFeatures);
  SET_PROC(DispatchSemanticsAction, FlutterEngineDispatchSemanticsAction);
  SET_PROC(SendSemanticsAction, FlutterEngineSendSemanticsAction);
  SET_PROC(OnVsync, FlutterEngineOnVsync);
  SET_PROC(ReloadSystemFonts, FlutterEngineReloadSystemFonts);
  SET_PROC(TraceEventDurationBegin, FlutterEngineTraceEventDurationBegin);
  SET_PROC(TraceEventDurationEnd, FlutterEngineTraceEventDurationEnd);
  SET_PROC(TraceEventInstant, FlutterEngineTraceEventInstant);
  SET_PROC(PostRenderThreadTask, FlutterEnginePostRenderThreadTask);
  SET_PROC(GetCurrentTime, FlutterEngineGetCurrentTime);
  SET_PROC(RunTask, FlutterEngineRunTask);
  SET_PROC(UpdateLocales, FlutterEngineUpdateLocales);
  SET_PROC(RunsAOTCompiledDartCode, FlutterEngineRunsAOTCompiledDartCode);
  SET_PROC(PostDartObject, FlutterEnginePostDartObject);
  SET_PROC(NotifyLowMemoryWarning, FlutterEngineNotifyLowMemoryWarning);
  SET_PROC(PostCallbackOnAllNativeThreads,
           FlutterEnginePostCallbackOnAllNativeThreads);
  SET_PROC(NotifyDisplayUpdate, FlutterEngineNotifyDisplayUpdate);
  SET_PROC(ScheduleFrame, FlutterEngineScheduleFrame);
  SET_PROC(SetNextFrameCallback, FlutterEngineSetNextFrameCallback);
  SET_PROC(AddView, FlutterEngineAddView);
  SET_PROC(RemoveView, FlutterEngineRemoveView);
  SET_PROC(SendViewFocusEvent, FlutterEngineSendViewFocusEvent);
#undef SET_PROC
 
  return kSuccess;
}

Referenced by fl_engine_init(), flutter::FlutterWindowsEngine::FlutterWindowsEngine(), flutter::testing::TEST(), flutter::testing::TEST(), and flutter::testing::TEST().

◆ FlutterEngineInitialize()

FLUTTER_EXPORT FlutterEngineResult FlutterEngineInitialize	(	size_t	version,
		const FlutterRendererConfig *	config,
		const FlutterProjectArgs *	args,
		void *	user_data,
		FLUTTER_API_SYMBOL(FlutterEngine) *	engine_out
	)

Initialize a Flutter engine instance. This does not run the Flutter application code till the FlutterEngineRunInitialized call is made. Besides Flutter application code, no tasks are scheduled on embedder managed task runners either. This allows embedders providing custom task runners to the Flutter engine to obtain a handle to the Flutter engine before the engine can post tasks on these task runners.

Parameters

[in]	version	The Flutter embedder API version. Must be FLUTTER_ENGINE_VERSION.
[in]	config	The renderer configuration.
[in]	args	The Flutter project arguments.
	user_data	A user data baton passed back to embedders in callbacks.
[out]	engine_out	The engine handle on successful engine creation.

Returns: The result of the call to initialize the Flutter engine.

Definition at line 1987 of file embedder.cc.

                                                            {
  // Step 0: Figure out arguments for shell creation.
  if (version != FLUTTER_ENGINE_VERSION) {
    return LOG_EMBEDDER_ERROR(
        kInvalidLibraryVersion,
        "Flutter embedder version mismatch. There has been a breaking change. "
        "Please consult the changelog and update the embedder.");
  }
 
  if (engine_out == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments,
                              "The engine out parameter was missing.");
  }
 
  if (args == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments,
                              "The Flutter project arguments were missing.");
  }
 
  if (SAFE_ACCESS(args, assets_path, nullptr) == nullptr) {
    return LOG_EMBEDDER_ERROR(
        kInvalidArguments,
        "The assets path in the Flutter project arguments was missing.");
  }
 
  if (SAFE_ACCESS(args, main_path__unused__, nullptr) != nullptr) {
    FML_LOG(WARNING)
        << "FlutterProjectArgs.main_path is deprecated and should be set null.";
  }
 
  if (SAFE_ACCESS(args, packages_path__unused__, nullptr) != nullptr) {
    FML_LOG(WARNING) << "FlutterProjectArgs.packages_path is deprecated and "
                        "should be set null.";
  }
 
  if (!IsRendererValid(config)) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments,
                              "The renderer configuration was invalid.");
  }
 
  std::string icu_data_path;
  if (SAFE_ACCESS(args, icu_data_path, nullptr) != nullptr) {
    icu_data_path = SAFE_ACCESS(args, icu_data_path, nullptr);
  }
 
#if !SLIMPELLER
  if (SAFE_ACCESS(args, persistent_cache_path, nullptr) != nullptr) {
    std::string persistent_cache_path =
        SAFE_ACCESS(args, persistent_cache_path, nullptr);
    flutter::PersistentCache::SetCacheDirectoryPath(persistent_cache_path);
  }
 
  if (SAFE_ACCESS(args, is_persistent_cache_read_only, false)) {
    flutter::PersistentCache::gIsReadOnly = true;
  }
#endif  //  !SLIMPELLER
 
  fml::CommandLine command_line;
  if (SAFE_ACCESS(args, command_line_argc, 0) != 0 &&
      SAFE_ACCESS(args, command_line_argv, nullptr) != nullptr) {
    command_line = fml::CommandLineFromArgcArgv(
        SAFE_ACCESS(args, command_line_argc, 0),
        SAFE_ACCESS(args, command_line_argv, nullptr));
  }
 
  flutter::Settings settings = flutter::SettingsFromCommandLine(command_line);
 
  if (SAFE_ACCESS(args, aot_data, nullptr)) {
    if (SAFE_ACCESS(args, vm_snapshot_data, nullptr) ||
        SAFE_ACCESS(args, vm_snapshot_instructions, nullptr) ||
        SAFE_ACCESS(args, isolate_snapshot_data, nullptr) ||
        SAFE_ACCESS(args, isolate_snapshot_instructions, nullptr)) {
      return LOG_EMBEDDER_ERROR(
          kInvalidArguments,
          "Multiple AOT sources specified. Embedders should provide either "
          "*_snapshot_* buffers or aot_data, not both.");
    }
  }
 
  if (flutter::DartVM::IsRunningPrecompiledCode()) {
    PopulateAOTSnapshotMappingCallbacks(args, settings);
  } else {
    PopulateJITSnapshotMappingCallbacks(args, settings);
  }
 
  settings.icu_data_path = icu_data_path;
  settings.assets_path = args->assets_path;
  settings.leak_vm = !SAFE_ACCESS(args, shutdown_dart_vm_when_done, false);
  settings.old_gen_heap_size = SAFE_ACCESS(args, dart_old_gen_heap_size, -1);
 
  if (!flutter::DartVM::IsRunningPrecompiledCode()) {
    // Verify the assets path contains Dart 2 kernel assets.
    const std::string kApplicationKernelSnapshotFileName = "kernel_blob.bin";
    std::string application_kernel_path = fml::paths::JoinPaths(
        {settings.assets_path, kApplicationKernelSnapshotFileName});
    if (!fml::IsFile(application_kernel_path)) {
      return LOG_EMBEDDER_ERROR(
          kInvalidArguments,
          "Not running in AOT mode but could not resolve the kernel binary.");
    }
    settings.application_kernel_asset = kApplicationKernelSnapshotFileName;
  }
 
  if (SAFE_ACCESS(args, root_isolate_create_callback, nullptr) != nullptr) {
    VoidCallback callback =
        SAFE_ACCESS(args, root_isolate_create_callback, nullptr);
    settings.root_isolate_create_callback =
        [callback, user_data](const auto& isolate) { callback(user_data); };
  }
 
  // Wire up callback for engine and print logging.
  if (SAFE_ACCESS(args, log_message_callback, nullptr) != nullptr) {
    FlutterLogMessageCallback callback =
        SAFE_ACCESS(args, log_message_callback, nullptr);
    settings.log_message_callback = [callback, user_data](
                                        const std::string& tag,
                                        const std::string& message) {
      callback(tag.c_str(), message.c_str(), user_data);
    };
  } else {
    settings.log_message_callback = [](const std::string& tag,
                                       const std::string& message) {
      // Fall back to logging to stdout if unspecified.
      if (tag.empty()) {
        std::cout << tag << ": ";
      }
      std::cout << message << std::endl;
    };
  }
 
  if (SAFE_ACCESS(args, log_tag, nullptr) != nullptr) {
    settings.log_tag = SAFE_ACCESS(args, log_tag, nullptr);
  }
 
  bool has_update_semantics_2_callback =
      SAFE_ACCESS(args, update_semantics_callback2, nullptr) != nullptr;
  bool has_update_semantics_callback =
      SAFE_ACCESS(args, update_semantics_callback, nullptr) != nullptr;
  bool has_legacy_update_semantics_callback =
      SAFE_ACCESS(args, update_semantics_node_callback, nullptr) != nullptr ||
      SAFE_ACCESS(args, update_semantics_custom_action_callback, nullptr) !=
          nullptr;
 
  int semantic_callback_count = (has_update_semantics_2_callback ? 1 : 0) +
                                (has_update_semantics_callback ? 1 : 0) +
                                (has_legacy_update_semantics_callback ? 1 : 0);
 
  if (semantic_callback_count > 1) {
    return LOG_EMBEDDER_ERROR(
        kInvalidArguments,
        "Multiple semantics update callbacks provided. "
        "Embedders should provide either `update_semantics_callback2`, "
        "`update_semantics_callback`, or both "
        "`update_semantics_node_callback` and "
        "`update_semantics_custom_action_callback`.");
  }
 
  flutter::PlatformViewEmbedder::UpdateSemanticsCallback
      update_semantics_callback =
          CreateEmbedderSemanticsUpdateCallback(args, user_data);
 
  flutter::PlatformViewEmbedder::PlatformMessageResponseCallback
      platform_message_response_callback = nullptr;
  if (SAFE_ACCESS(args, platform_message_callback, nullptr) != nullptr) {
    platform_message_response_callback =
        [ptr = args->platform_message_callback,
         user_data](std::unique_ptr<flutter::PlatformMessage> message) {
          auto handle = new FlutterPlatformMessageResponseHandle();
          const FlutterPlatformMessage incoming_message = {
              sizeof(FlutterPlatformMessage),  // struct_size
              message->channel().c_str(),      // channel
              message->data().GetMapping(),    // message
              message->data().GetSize(),       // message_size
              handle,                          // response_handle
          };
          handle->message = std::move(message);
          return ptr(&incoming_message, user_data);
        };
  }
 
  flutter::VsyncWaiterEmbedder::VsyncCallback vsync_callback = nullptr;
  if (SAFE_ACCESS(args, vsync_callback, nullptr) != nullptr) {
    vsync_callback = [ptr = args->vsync_callback, user_data](intptr_t baton) {
      return ptr(user_data, baton);
    };
  }
 
  flutter::PlatformViewEmbedder::ComputePlatformResolvedLocaleCallback
      compute_platform_resolved_locale_callback = nullptr;
  if (SAFE_ACCESS(args, compute_platform_resolved_locale_callback, nullptr) !=
      nullptr) {
    compute_platform_resolved_locale_callback =
        [ptr = args->compute_platform_resolved_locale_callback](
            const std::vector<std::string>& supported_locales_data) {
          const size_t number_of_strings_per_locale = 3;
          size_t locale_count =
              supported_locales_data.size() / number_of_strings_per_locale;
          std::vector<FlutterLocale> supported_locales;
          std::vector<const FlutterLocale*> supported_locales_ptr;
          for (size_t i = 0; i < locale_count; ++i) {
            supported_locales.push_back(
                {.struct_size = sizeof(FlutterLocale),
                 .language_code =
                     supported_locales_data[i * number_of_strings_per_locale +
                                            0]
                         .c_str(),
                 .country_code =
                     supported_locales_data[i * number_of_strings_per_locale +
                                            1]
                         .c_str(),
                 .script_code =
                     supported_locales_data[i * number_of_strings_per_locale +
                                            2]
                         .c_str(),
                 .variant_code = nullptr});
            supported_locales_ptr.push_back(&supported_locales[i]);
          }
 
          const FlutterLocale* result =
              ptr(supported_locales_ptr.data(), locale_count);
 
          std::unique_ptr<std::vector<std::string>> out =
              std::make_unique<std::vector<std::string>>();
          if (result) {
            std::string language_code(SAFE_ACCESS(result, language_code, ""));
            if (language_code != "") {
              out->push_back(language_code);
              out->emplace_back(SAFE_ACCESS(result, country_code, ""));
              out->emplace_back(SAFE_ACCESS(result, script_code, ""));
            }
          }
          return out;
        };
  }
 
  flutter::PlatformViewEmbedder::OnPreEngineRestartCallback
      on_pre_engine_restart_callback = nullptr;
  if (SAFE_ACCESS(args, on_pre_engine_restart_callback, nullptr) != nullptr) {
    on_pre_engine_restart_callback = [ptr =
                                          args->on_pre_engine_restart_callback,
                                      user_data]() { return ptr(user_data); };
  }
 
  flutter::PlatformViewEmbedder::ChanneUpdateCallback channel_update_callback =
      nullptr;
  if (SAFE_ACCESS(args, channel_update_callback, nullptr) != nullptr) {
    channel_update_callback = [ptr = args->channel_update_callback, user_data](
                                  const std::string& name, bool listening) {
      FlutterChannelUpdate update{sizeof(FlutterChannelUpdate), name.c_str(),
                                  listening};
      ptr(&update, user_data);
    };
  }
 
  flutter::PlatformViewEmbedder::ViewFocusChangeRequestCallback
      view_focus_change_request_callback = nullptr;
  if (SAFE_ACCESS(args, view_focus_change_request_callback, nullptr) !=
      nullptr) {
    view_focus_change_request_callback =
        [ptr = args->view_focus_change_request_callback,
         user_data](const flutter::ViewFocusChangeRequest& request) {
          FlutterViewFocusChangeRequest embedder_request{
              .struct_size = sizeof(FlutterViewFocusChangeRequest),
              .view_id = request.view_id(),
              .state = static_cast<FlutterViewFocusState>(request.state()),
              .direction =
                  static_cast<FlutterViewFocusDirection>(request.direction()),
          };
          ptr(&embedder_request, user_data);
        };
  }
 
  auto external_view_embedder_result = InferExternalViewEmbedderFromArgs(
      SAFE_ACCESS(args, compositor, nullptr), settings.enable_impeller);
  if (!external_view_embedder_result.ok()) {
    FML_LOG(ERROR) << external_view_embedder_result.status().message();
    return LOG_EMBEDDER_ERROR(kInvalidArguments,
                              "Compositor arguments were invalid.");
  }
 
  flutter::PlatformViewEmbedder::PlatformDispatchTable platform_dispatch_table =
      {
          update_semantics_callback,                  //
          platform_message_response_callback,         //
          vsync_callback,                             //
          compute_platform_resolved_locale_callback,  //
          on_pre_engine_restart_callback,             //
          channel_update_callback,                    //
          view_focus_change_request_callback,         //
      };
 
  auto on_create_platform_view = InferPlatformViewCreationCallback(
      config, user_data, platform_dispatch_table,
      std::move(external_view_embedder_result.value()),
      settings.enable_impeller);
 
  if (!on_create_platform_view) {
    return LOG_EMBEDDER_ERROR(
        kInternalInconsistency,
        "Could not infer platform view creation callback.");
  }
 
  flutter::Shell::CreateCallback<flutter::Rasterizer> on_create_rasterizer =
      [](flutter::Shell& shell) {
        return std::make_unique<flutter::Rasterizer>(shell);
      };
 
  using ExternalTextureResolver = flutter::EmbedderExternalTextureResolver;
  std::unique_ptr<ExternalTextureResolver> external_texture_resolver;
  external_texture_resolver = std::make_unique<ExternalTextureResolver>();
 
#ifdef SHELL_ENABLE_GL
  flutter::EmbedderExternalTextureGL::ExternalTextureCallback
      external_texture_callback;
  if (config->type == kOpenGL) {
    const FlutterOpenGLRendererConfig* open_gl_config = &config->open_gl;
    if (SAFE_ACCESS(open_gl_config, gl_external_texture_frame_callback,
                    nullptr) != nullptr) {
      external_texture_callback =
          [ptr = open_gl_config->gl_external_texture_frame_callback, user_data](
              int64_t texture_identifier, size_t width,
              size_t height) -> std::unique_ptr<FlutterOpenGLTexture> {
        std::unique_ptr<FlutterOpenGLTexture> texture =
            std::make_unique<FlutterOpenGLTexture>();
        if (!ptr(user_data, texture_identifier, width, height, texture.get())) {
          return nullptr;
        }
        return texture;
      };
      external_texture_resolver =
          std::make_unique<ExternalTextureResolver>(external_texture_callback);
    }
  }
#endif
#ifdef SHELL_ENABLE_METAL
  flutter::EmbedderExternalTextureMetal::ExternalTextureCallback
      external_texture_metal_callback;
  if (config->type == kMetal) {
    const FlutterMetalRendererConfig* metal_config = &config->metal;
    if (SAFE_ACCESS(metal_config, external_texture_frame_callback, nullptr)) {
      external_texture_metal_callback =
          [ptr = metal_config->external_texture_frame_callback, user_data](
              int64_t texture_identifier, size_t width,
              size_t height) -> std::unique_ptr<FlutterMetalExternalTexture> {
        std::unique_ptr<FlutterMetalExternalTexture> texture =
            std::make_unique<FlutterMetalExternalTexture>();
        texture->struct_size = sizeof(FlutterMetalExternalTexture);
        if (!ptr(user_data, texture_identifier, width, height, texture.get())) {
          return nullptr;
        }
        return texture;
      };
      external_texture_resolver = std::make_unique<ExternalTextureResolver>(
          external_texture_metal_callback);
    }
  }
#endif
  auto custom_task_runners = SAFE_ACCESS(args, custom_task_runners, nullptr);
  auto thread_config_callback = [&custom_task_runners](
                                    const fml::Thread::ThreadConfig& config) {
    fml::Thread::SetCurrentThreadName(config);
    if (!custom_task_runners || !custom_task_runners->thread_priority_setter) {
      return;
    }
    FlutterThreadPriority priority = FlutterThreadPriority::kNormal;
    switch (config.priority) {
      case fml::Thread::ThreadPriority::kBackground:
        priority = FlutterThreadPriority::kBackground;
        break;
      case fml::Thread::ThreadPriority::kNormal:
        priority = FlutterThreadPriority::kNormal;
        break;
      case fml::Thread::ThreadPriority::kDisplay:
        priority = FlutterThreadPriority::kDisplay;
        break;
      case fml::Thread::ThreadPriority::kRaster:
        priority = FlutterThreadPriority::kRaster;
        break;
    }
    custom_task_runners->thread_priority_setter(priority);
  };
  auto thread_host =
      flutter::EmbedderThreadHost::CreateEmbedderOrEngineManagedThreadHost(
          custom_task_runners, thread_config_callback);
 
  if (!thread_host || !thread_host->IsValid()) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments,
                              "Could not set up or infer thread configuration "
                              "to run the Flutter engine on.");
  }
 
  auto task_runners = thread_host->GetTaskRunners();
 
  if (!task_runners.IsValid()) {
    return LOG_EMBEDDER_ERROR(kInternalInconsistency,
                              "Task runner configuration was invalid.");
  }
 
  // Embedder supplied UI task runner runner does not have a message loop.
  bool has_ui_thread_message_loop =
      task_runners.GetUITaskRunner()->GetTaskQueueId().is_valid();
  // Message loop observers are used to flush the microtask queue.
  // If there is no message loop the queue is flushed from
  // EmbedderEngine::RunTask.
  settings.task_observer_add = [has_ui_thread_message_loop](
                                   intptr_t key, const fml::closure& callback) {
    if (has_ui_thread_message_loop) {
      fml::MessageLoop::GetCurrent().AddTaskObserver(key, callback);
    }
    return fml::TaskQueueId::Invalid();
  };
  settings.task_observer_remove = [has_ui_thread_message_loop](
                                      fml::TaskQueueId queue_id, intptr_t key) {
    if (has_ui_thread_message_loop) {
      fml::MessageLoop::GetCurrent().RemoveTaskObserver(key);
    }
  };
 
  auto run_configuration =
      flutter::RunConfiguration::InferFromSettings(settings);
 
  if (SAFE_ACCESS(args, custom_dart_entrypoint, nullptr) != nullptr) {
    auto dart_entrypoint = std::string{args->custom_dart_entrypoint};
    if (!dart_entrypoint.empty()) {
      run_configuration.SetEntrypoint(std::move(dart_entrypoint));
    }
  }
 
  if (SAFE_ACCESS(args, dart_entrypoint_argc, 0) > 0) {
    if (SAFE_ACCESS(args, dart_entrypoint_argv, nullptr) == nullptr) {
      return LOG_EMBEDDER_ERROR(kInvalidArguments,
                                "Could not determine Dart entrypoint arguments "
                                "as dart_entrypoint_argc "
                                "was set, but dart_entrypoint_argv was null.");
    }
    std::vector<std::string> arguments(args->dart_entrypoint_argc);
    for (int i = 0; i < args->dart_entrypoint_argc; ++i) {
      arguments[i] = std::string{args->dart_entrypoint_argv[i]};
    }
    run_configuration.SetEntrypointArgs(std::move(arguments));
  }
 
  if (SAFE_ACCESS(args, engine_id, 0) != 0) {
    run_configuration.SetEngineId(args->engine_id);
  }
 
  if (!run_configuration.IsValid()) {
    return LOG_EMBEDDER_ERROR(
        kInvalidArguments,
        "Could not infer the Flutter project to run from given arguments.");
  }
 
  // Create the engine but don't launch the shell or run the root isolate.
  auto embedder_engine = std::make_unique<flutter::EmbedderEngine>(
      std::move(thread_host),               //
      std::move(task_runners),              //
      std::move(settings),                  //
      std::move(run_configuration),         //
      on_create_platform_view,              //
      on_create_rasterizer,                 //
      std::move(external_texture_resolver)  //
  );
 
  // Release the ownership of the embedder engine to the caller.
  *engine_out = reinterpret_cast<FLUTTER_API_SYMBOL(FlutterEngine)>(
      embedder_engine.release());
  return kSuccess;
}

References fml::MessageLoop::AddTaskObserver(), flutter::Settings::application_kernel_asset, args, flutter::Settings::assets_path, callback, FlutterPlatformMessage::channel, fml::CommandLineFromArgcArgv(), flutter::EmbedderThreadHost::CreateEmbedderOrEngineManagedThreadHost(), CreateEmbedderSemanticsUpdateCallback(), flutter::Settings::enable_impeller, FlutterMetalRendererConfig::external_texture_frame_callback, FLUTTER_API_SYMBOL, FLUTTER_ENGINE_VERSION, FML_LOG, fml::MessageLoop::GetCurrent(), flutter::PersistentCache::gIsReadOnly, FlutterOpenGLRendererConfig::gl_external_texture_frame_callback, height, i, flutter::Settings::icu_data_path, InferExternalViewEmbedderFromArgs(), flutter::RunConfiguration::InferFromSettings(), InferPlatformViewCreationCallback(), fml::TaskQueueId::Invalid(), fml::IsFile(), IsRendererValid(), flutter::DartVM::IsRunningPrecompiledCode(), fml::paths::JoinPaths(), kApplicationKernelSnapshotFileName, fml::Thread::kBackground, kBackground, fml::Thread::kDisplay, kDisplay, key, kInternalInconsistency, kInvalidArguments, kInvalidLibraryVersion, kMetal, fml::Thread::kNormal, kNormal, kOpenGL, fml::Thread::kRaster, kRaster, kSuccess, flutter::Settings::leak_vm, LOG_EMBEDDER_ERROR, flutter::Settings::log_message_callback, flutter::Settings::log_tag, message, FlutterRendererConfig::metal, name, flutter::Settings::old_gen_heap_size, FlutterRendererConfig::open_gl, PopulateAOTSnapshotMappingCallbacks(), PopulateJITSnapshotMappingCallbacks(), fml::MessageLoop::RemoveTaskObserver(), flutter::Settings::root_isolate_create_callback, SAFE_ACCESS, flutter::PersistentCache::SetCacheDirectoryPath(), fml::Thread::SetCurrentThreadName(), flutter::SettingsFromCommandLine(), FlutterViewFocusChangeRequest::struct_size, flutter::Settings::task_observer_add, flutter::Settings::task_observer_remove, texture, FlutterRendererConfig::type, user_data, view_id, and width.

Referenced by FlutterEngineGetProcAddresses(), and FlutterEngineRun().

◆ FlutterEngineMarkExternalTextureFrameAvailable()

FLUTTER_EXPORT FlutterEngineResult FlutterEngineMarkExternalTextureFrameAvailable	(	FLUTTER_API_SYMBOL(FlutterEngine)	engine,
		int64_t	texture_identifier
	)

Mark that a new texture frame is available for a given texture identifier.

See also: FlutterEngineRegisterExternalTexture(); FlutterEngineUnregisterExternalTexture()

Parameters

[in]	engine	A running engine instance.
[in]	texture_identifier	The identifier of the texture whose frame has been updated.

Returns: The result of the call.

Definition at line 3150 of file embedder.cc.

                                {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Invalid engine handle.");
  }
  if (texture_identifier == 0) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Invalid texture identifier.");
  }
  if (!reinterpret_cast<flutter::EmbedderEngine*>(engine)
           ->MarkTextureFrameAvailable(texture_identifier)) {
    return LOG_EMBEDDER_ERROR(
        kInternalInconsistency,
        "Could not mark the texture frame as being available.");
  }
  return kSuccess;
}

References engine, kInternalInconsistency, kInvalidArguments, kSuccess, and LOG_EMBEDDER_ERROR.

Referenced by FlutterEngineGetProcAddresses().

◆ FlutterEngineNotifyDisplayUpdate()

FLUTTER_EXPORT FlutterEngineResult FlutterEngineNotifyDisplayUpdate	(	FLUTTER_API_SYMBOL(FlutterEngine)	engine,
		FlutterEngineDisplaysUpdateType	update_type,
		const FlutterEngineDisplay *	displays,
		size_t	display_count
	)

Posts updates corresponding to display changes to a running engine instance.

Parameters

[in]	update_type	The type of update pushed to the engine.
[in]	displays	The displays affected by this update.
[in]	display_count	Size of the displays array, must be at least 1.

Returns: the result of the call made to the engine.

Definition at line 3613 of file embedder.cc.

                          {
  if (raw_engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Invalid engine handle.");
  }
 
  if (!ValidDisplayConfiguration(embedder_displays, display_count)) {
    return LOG_EMBEDDER_ERROR(
        kInvalidArguments,
        "Invalid FlutterEngineDisplay configuration specified.");
  }
 
  auto engine = reinterpret_cast<flutter::EmbedderEngine*>(raw_engine);
 
  switch (update_type) {
    case kFlutterEngineDisplaysUpdateTypeStartup: {
      std::vector<std::unique_ptr<flutter::Display>> displays;
      const auto* display = embedder_displays;
      for (size_t i = 0; i < display_count; i++) {
        displays.push_back(std::make_unique<flutter::Display>(
            SAFE_ACCESS(display, display_id, i),    //
            SAFE_ACCESS(display, refresh_rate, 0),  //
            SAFE_ACCESS(display, width, 0),         //
            SAFE_ACCESS(display, height, 0),        //
            SAFE_ACCESS(display, device_pixel_ratio, 1)));
        display = reinterpret_cast<const FlutterEngineDisplay*>(
            reinterpret_cast<const uint8_t*>(display) + display->struct_size);
      }
      engine->GetShell().OnDisplayUpdates(std::move(displays));
      return kSuccess;
    }
    default:
      return LOG_EMBEDDER_ERROR(
          kInvalidArguments,
          "Invalid FlutterEngineDisplaysUpdateType type specified.");
  }
}

References displays, engine, height, i, kFlutterEngineDisplaysUpdateTypeStartup, kInvalidArguments, kSuccess, LOG_EMBEDDER_ERROR, SAFE_ACCESS, and width.

Referenced by FlutterEngineGetProcAddresses(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

◆ FlutterEngineNotifyLowMemoryWarning()

FLUTTER_EXPORT FlutterEngineResult FlutterEngineNotifyLowMemoryWarning ( FLUTTER_API_SYMBOL(FlutterEngine) engine )

Posts a low memory notification to a running engine instance. The engine will do its best to release non-critical resources in response. It is not guaranteed that the resource would have been collected by the time this call returns however. The notification is posted to engine subsystems that may be operating on other threads.

Flutter applications can respond to these notifications by setting WidgetsBindingObserver.didHaveMemoryPressure observers.

Parameters

[in] engine A running engine instance.

Returns: If the low memory notification was sent to the running engine instance.

Definition at line 3552 of file embedder.cc.

                                                  {
  auto engine = reinterpret_cast<flutter::EmbedderEngine*>(raw_engine);
  if (engine == nullptr || !engine->IsValid()) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Engine was invalid.");
  }
 
  engine->GetShell().NotifyLowMemoryWarning();
 
  rapidjson::Document document;
  auto& allocator = document.GetAllocator();
 
  document.SetObject();
  document.AddMember("type", "memoryPressure", allocator);
 
  return DispatchJSONPlatformMessage(raw_engine, document, "flutter/system")
             ? kSuccess
             : LOG_EMBEDDER_ERROR(
                   kInternalInconsistency,
                   "Could not dispatch the low memory notification message.");
}

References DispatchJSONPlatformMessage(), engine, kInternalInconsistency, kInvalidArguments, kSuccess, and LOG_EMBEDDER_ERROR.

Referenced by FlutterEngineGetProcAddresses(), and flutter::testing::TEST_F().

◆ FlutterEngineOnVsync()

FLUTTER_EXPORT FlutterEngineResult FlutterEngineOnVsync	(	FLUTTER_API_SYMBOL(FlutterEngine)	engine,
		intptr_t	baton,
		uint64_t	frame_start_time_nanos,
		uint64_t	frame_target_time_nanos
	)

Notify the engine that a vsync event occurred. A baton passed to the platform via the vsync callback must be returned. This call must be made on the thread on which the call to FlutterEngineRun was made.

See also: FlutterEngineGetCurrentTime()

Attention: That frame timepoints are in nanoseconds.; The system monotonic clock is used as the timebase.

Parameters

[in]	engine.	A running engine instance.
[in]	baton	The baton supplied by the engine.
[in]	frame_start_time_nanos	The point at which the vsync event occurred or will occur. If the time point is in the future, the engine will wait till that point to begin its frame workload.
[in]	frame_target_time_nanos	The point at which the embedder anticipates the next vsync to occur. This is a hint the engine uses to schedule Dart VM garbage collection in periods in which the various threads are most likely to be idle. For example, for a 60Hz display, embedders should add 16.6 * 1e6 to the frame time field.

Returns: The result of the call.

Definition at line 3229 of file embedder.cc.

                                                                           {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Invalid engine handle.");
  }
 
  TRACE_EVENT0("flutter", "FlutterEngineOnVsync");
 
  auto start_time = fml::TimePoint::FromEpochDelta(
      fml::TimeDelta::FromNanoseconds(frame_start_time_nanos));
 
  auto target_time = fml::TimePoint::FromEpochDelta(
      fml::TimeDelta::FromNanoseconds(frame_target_time_nanos));
 
  if (!reinterpret_cast<flutter::EmbedderEngine*>(engine)->OnVsyncEvent(
          baton, start_time, target_time)) {
    return LOG_EMBEDDER_ERROR(
        kInternalInconsistency,
        "Could not notify the running engine instance of a Vsync event.");
  }
 
  return kSuccess;
}

References engine, fml::TimePoint::FromEpochDelta(), fml::TimeDelta::FromNanoseconds(), kInternalInconsistency, kInvalidArguments, kSuccess, LOG_EMBEDDER_ERROR, and TRACE_EVENT0.

Referenced by FlutterEngineGetProcAddresses(), and flutter::testing::TEST_F().

◆ FlutterEnginePostCallbackOnAllNativeThreads()

FLUTTER_EXPORT FlutterEngineResult FlutterEnginePostCallbackOnAllNativeThreads	(	FLUTTER_API_SYMBOL(FlutterEngine)	engine,
		FlutterNativeThreadCallback	callback,
		void *	user_data
	)

Schedule a callback to be run on all engine managed threads. The engine will attempt to service this callback the next time the message loop for each managed thread is idle. Since the engine manages the entire lifecycle of multiple threads, there is no opportunity for the embedders to finely tune the priorities of threads directly, or, perform other thread specific configuration (for example, setting thread names for tracing). This callback gives embedders a chance to affect such tuning.

Attention: This call is expensive and must be made as few times as possible. The callback must also return immediately as not doing so may risk performance issues (especially for callbacks of type kFlutterNativeThreadTypeUI and kFlutterNativeThreadTypeRender).; Some callbacks (especially the ones of type kFlutterNativeThreadTypeWorker) may be called after the FlutterEngine instance has shut down. Embedders must be careful in handling the lifecycle of objects associated with the user data baton.; In case there are multiple running Flutter engine instances, their workers are shared.

Parameters

[in]	engine	A running engine instance.
[in]	callback	The callback that will get called multiple times on each engine managed thread.
[in]	user_data	A baton passed by the engine to the callback. This baton is not interpreted by the engine in any way.

Returns: Returns if the callback was successfully posted to all threads.

Definition at line 3574 of file embedder.cc.

                     {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Invalid engine handle.");
  }
 
  if (callback == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments,
                              "Invalid native thread callback.");
  }
 
  return reinterpret_cast<flutter::EmbedderEngine*>(engine)
                 ->PostTaskOnEngineManagedNativeThreads(
                     [callback, user_data](FlutterNativeThreadType type) {
                       callback(type, user_data);
                     })
             ? kSuccess
             : LOG_EMBEDDER_ERROR(kInvalidArguments,
                                  "Internal error while attempting to post "
                                  "tasks to all threads.");
}

References callback, engine, kInvalidArguments, kSuccess, LOG_EMBEDDER_ERROR, type, and user_data.

Referenced by FlutterEngineGetProcAddresses(), and flutter::testing::TEST_F().

◆ FlutterEnginePostDartObject()

FLUTTER_EXPORT FlutterEngineResult FlutterEnginePostDartObject	(	FLUTTER_API_SYMBOL(FlutterEngine)	engine,
		FlutterEngineDartPort	port,
		const FlutterEngineDartObject *	object
	)

Posts a Dart object to specified send port. The corresponding receive port for send port can be in any isolate running in the VM. This isolate can also be the root isolate for an unrelated engine. The engine parameter is necessary only to ensure the call is not made when no engine (and hence no VM) is running.

Unlike the platform messages mechanism, there are no threading restrictions when using this API. Message can be posted on any thread and they will be made available to isolate on which the corresponding send port is listening.

However, it is the embedders responsibility to ensure that the call is not made during an ongoing call the FlutterEngineDeinitialize or FlutterEngineShutdown on another thread.

Parameters

[in]	engine	A running engine instance.
[in]	port	The send port to send the object to.
[in]	object	The object to send to the isolate with the corresponding receive port.

Returns: If the message was posted to the send port.

Definition at line 3428 of file embedder.cc.

                                           {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Invalid engine handle.");
  }
 
  if (!reinterpret_cast<flutter::EmbedderEngine*>(engine)->IsValid()) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Engine not running.");
  }
 
  if (port == ILLEGAL_PORT) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments,
                              "Attempted to post to an illegal port.");
  }
 
  if (object == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments,
                              "Invalid Dart object to post.");
  }
 
  Dart_CObject dart_object = {};
  fml::ScopedCleanupClosure typed_data_finalizer;
 
  switch (object->type) {
    case kFlutterEngineDartObjectTypeNull:
      dart_object.type = Dart_CObject_kNull;
      break;
    case kFlutterEngineDartObjectTypeBool:
      dart_object.type = Dart_CObject_kBool;
      dart_object.value.as_bool = object->bool_value;
      break;
    case kFlutterEngineDartObjectTypeInt32:
      dart_object.type = Dart_CObject_kInt32;
      dart_object.value.as_int32 = object->int32_value;
      break;
    case kFlutterEngineDartObjectTypeInt64:
      dart_object.type = Dart_CObject_kInt64;
      dart_object.value.as_int64 = object->int64_value;
      break;
    case kFlutterEngineDartObjectTypeDouble:
      dart_object.type = Dart_CObject_kDouble;
      dart_object.value.as_double = object->double_value;
      break;
    case kFlutterEngineDartObjectTypeString:
      if (object->string_value == nullptr) {
        return LOG_EMBEDDER_ERROR(kInvalidArguments,
                                  "kFlutterEngineDartObjectTypeString must be "
                                  "a null terminated string but was null.");
      }
      dart_object.type = Dart_CObject_kString;
      dart_object.value.as_string = const_cast<char*>(object->string_value);
      break;
    case kFlutterEngineDartObjectTypeBuffer: {
      auto* buffer = SAFE_ACCESS(object->buffer_value, buffer, nullptr);
      if (buffer == nullptr) {
        return LOG_EMBEDDER_ERROR(kInvalidArguments,
                                  "kFlutterEngineDartObjectTypeBuffer must "
                                  "specify a buffer but found nullptr.");
      }
      auto buffer_size = SAFE_ACCESS(object->buffer_value, buffer_size, 0);
      auto callback =
          SAFE_ACCESS(object->buffer_value, buffer_collect_callback, nullptr);
      auto user_data = SAFE_ACCESS(object->buffer_value, user_data, nullptr);
 
      // The user has provided a callback, let them manage the lifecycle of
      // the underlying data. If not, copy it out from the provided buffer.
 
      if (callback == nullptr) {
        dart_object.type = Dart_CObject_kTypedData;
        dart_object.value.as_typed_data.type = Dart_TypedData_kUint8;
        dart_object.value.as_typed_data.length = buffer_size;
        dart_object.value.as_typed_data.values = buffer;
      } else {
        struct ExternalTypedDataPeer {
          void* user_data = nullptr;
          VoidCallback trampoline = nullptr;
        };
        auto peer = new ExternalTypedDataPeer();
        peer->user_data = user_data;
        peer->trampoline = callback;
        // This finalizer is set so that in case of failure of the
        // Dart_PostCObject below, we collect the peer. The embedder is still
        // responsible for collecting the buffer in case of non-kSuccess
        // returns from this method. This finalizer must be released in case
        // of kSuccess returns from this method.
        typed_data_finalizer.SetClosure([peer]() {
          // This is the tiny object we use as the peer to the Dart call so
          // that we can attach the a trampoline to the embedder supplied
          // callback. In case of error, we need to collect this object lest
          // we introduce a tiny leak.
          delete peer;
        });
        dart_object.type = Dart_CObject_kExternalTypedData;
        dart_object.value.as_external_typed_data.type = Dart_TypedData_kUint8;
        dart_object.value.as_external_typed_data.length = buffer_size;
        dart_object.value.as_external_typed_data.data = buffer;
        dart_object.value.as_external_typed_data.peer = peer;
        dart_object.value.as_external_typed_data.callback =
            +[](void* unused_isolate_callback_data, void* peer) {
              auto typed_peer = reinterpret_cast<ExternalTypedDataPeer*>(peer);
              typed_peer->trampoline(typed_peer->user_data);
              delete typed_peer;
            };
      }
    } break;
    default:
      return LOG_EMBEDDER_ERROR(
          kInvalidArguments,
          "Invalid FlutterEngineDartObjectType type specified.");
  }
 
  if (!Dart_PostCObject(port, &dart_object)) {
    return LOG_EMBEDDER_ERROR(kInternalInconsistency,
                              "Could not post the object to the Dart VM.");
  }
 
  // On a successful call, the VM takes ownership of and is responsible for
  // invoking the finalizer.
  typed_data_finalizer.Release();
  return kSuccess;
}

Referenced by FlutterEngineGetProcAddresses(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

◆ FlutterEnginePostRenderThreadTask()

FLUTTER_EXPORT FlutterEngineResult FlutterEnginePostRenderThreadTask	(	FLUTTER_API_SYMBOL(FlutterEngine)	engine,
		VoidCallback	callback,
		void *	callback_data
	)

Posts a task onto the Flutter render thread. Typically, this may be called from any thread as long as a FlutterEngineShutdown on the specific engine has not already been initiated.

Parameters

[in]	engine	A running engine instance.
[in]	callback	The callback to execute on the render thread.
	callback_data	The callback context.

Returns: The result of the call.

Definition at line 3287 of file embedder.cc.

                 {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Invalid engine handle.");
  }
 
  if (callback == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments,
                              "Render thread callback was null.");
  }
 
  auto task = [callback, baton]() { callback(baton); };
 
  return reinterpret_cast<flutter::EmbedderEngine*>(engine)
                 ->PostRenderThreadTask(task)
             ? kSuccess
             : LOG_EMBEDDER_ERROR(kInternalInconsistency,
                                  "Could not post the render thread task.");
}

References callback, engine, kInternalInconsistency, kInvalidArguments, kSuccess, and LOG_EMBEDDER_ERROR.

Referenced by FlutterEngineGetProcAddresses().

◆ FlutterEngineRegisterExternalTexture()

FLUTTER_EXPORT FlutterEngineResult FlutterEngineRegisterExternalTexture	(	FLUTTER_API_SYMBOL(FlutterEngine)	engine,
		int64_t	texture_identifier
	)

Register an external texture with a unique (per engine) identifier. Only rendering backends that support external textures accept external texture registrations. After the external texture is registered, the application can mark that a frame is available by calling FlutterEngineMarkExternalTextureFrameAvailable.

See also: FlutterEngineUnregisterExternalTexture(); FlutterEngineMarkExternalTextureFrameAvailable()

Parameters

[in]	engine	A running engine instance.
[in]	texture_identifier	The identifier of the texture to register with the engine. The embedder may supply new frames to this texture using the same identifier.

Returns: The result of the call.

Definition at line 3110 of file embedder.cc.

                                {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Engine handle was invalid.");
  }
 
  if (texture_identifier == 0) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments,
                              "Texture identifier was invalid.");
  }
  if (!reinterpret_cast<flutter::EmbedderEngine*>(engine)->RegisterTexture(
          texture_identifier)) {
    return LOG_EMBEDDER_ERROR(kInternalInconsistency,
                              "Could not register the specified texture.");
  }
  return kSuccess;
}

References engine, kInternalInconsistency, kInvalidArguments, kSuccess, and LOG_EMBEDDER_ERROR.

Referenced by FlutterEngineGetProcAddresses(), and flutter::testing::TEST_F().

◆ FlutterEngineReloadSystemFonts()

FLUTTER_EXPORT FlutterEngineResult FlutterEngineReloadSystemFonts ( FLUTTER_API_SYMBOL(FlutterEngine) engine )

Reloads the system fonts in engine.

Parameters

[in] engine. A running engine instance.

Returns: The result of the call.

Definition at line 3256 of file embedder.cc.

                                              {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Invalid engine handle.");
  }
 
  TRACE_EVENT0("flutter", "FlutterEngineReloadSystemFonts");
 
  if (!reinterpret_cast<flutter::EmbedderEngine*>(engine)
           ->ReloadSystemFonts()) {
    return LOG_EMBEDDER_ERROR(kInternalInconsistency,
                              "Could not reload system fonts.");
  }
 
  return kSuccess;
}

References engine, kInternalInconsistency, kInvalidArguments, kSuccess, LOG_EMBEDDER_ERROR, and TRACE_EVENT0.

Referenced by FlutterEngineGetProcAddresses(), and flutter::testing::TEST_F().

◆ FlutterEngineRemoveView()

FLUTTER_EXPORT FlutterEngineResult FlutterEngineRemoveView	(	FLUTTER_API_SYMBOL(FlutterEngine)	engine,
		const FlutterRemoveViewInfo *	info
	)

Removes a view.

        This is an asynchronous operation. The view's resources must not
        be cleaned up until |info.remove_view_callback| is invoked with
        a |removed| value of true.

        The callback is invoked on a thread managed by the engine. The
        embedder should re-thread if needed.

        Attempting to remove the implicit view will fail and will return
        kInvalidArguments. Attempting to remove a view with a
        non-existent view ID will fail, and |info.remove_view_callback|
        will be invoked with a |removed| value of false.

Parameters

[in]	engine	A running engine instance.
[in]	info	The remove view arguments. This can be deallocated once \|FlutterEngineRemoveView\| returns, before \|remove_view_callback\| is invoked.

Returns: The result of starting the asynchronous operation. If kSuccess, the |remove_view_callback| will be invoked.

Definition at line 2561 of file embedder.cc.

                                                                               {
  if (!engine) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Engine handle was invalid.");
  }
  if (!info || !info->remove_view_callback) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments,
                              "Remove view info handle was invalid.");
  }
 
  if (info->view_id == kFlutterImplicitViewId) {
    return LOG_EMBEDDER_ERROR(
        kInvalidArguments,
        "Remove view info was invalid. The implicit view cannot be removed.");
  }
 
  // TODO(loicsharma): Return an error if the engine was initialized with
  // callbacks that are incompatible with multiple views.
  // https://github.com/flutter/flutter/issues/144806
 
  // The engine must be running to remove a view.
  auto embedder_engine = reinterpret_cast<flutter::EmbedderEngine*>(engine);
  if (!embedder_engine->IsValid()) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Engine handle was invalid.");
  }
 
  flutter::PlatformView::RemoveViewCallback callback =
      [c_callback = info->remove_view_callback,
       user_data = info->user_data](bool removed) {
        FlutterRemoveViewResult result = {};
        result.struct_size = sizeof(FlutterRemoveViewResult);
        result.removed = removed;
        result.user_data = user_data;
        c_callback(&result);
      };
 
  embedder_engine->GetShell().GetPlatformView()->RemoveView(info->view_id,
                                                            callback);
  return kSuccess;
}

References callback, engine, kFlutterImplicitViewId, kInvalidArguments, kSuccess, LOG_EMBEDDER_ERROR, FlutterRemoveViewInfo::remove_view_callback, FlutterRemoveViewResult::removed, FlutterRemoveViewResult::struct_size, user_data, FlutterRemoveViewResult::user_data, FlutterRemoveViewInfo::user_data, and FlutterRemoveViewInfo::view_id.

Referenced by FlutterEngineGetProcAddresses(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

◆ FlutterEngineRun()

FLUTTER_EXPORT FlutterEngineResult FlutterEngineRun	(	size_t	version,
		const FlutterRendererConfig *	config,
		const FlutterProjectArgs *	args,
		void *	user_data,
		FLUTTER_API_SYMBOL(FlutterEngine) *	engine_out
	)

Initialize and run a Flutter engine instance and return a handle to it. This is a convenience method for the pair of calls to FlutterEngineInitialize and FlutterEngineRunInitialized.

Note: This method of running a Flutter engine works well except in cases where the embedder specifies custom task runners via FlutterProjectArgs::custom_task_runners. In such cases, the engine may need the embedder to post tasks back to it before FlutterEngineRun has returned. Embedders can only post tasks to the engine if they have a handle to the engine. In such cases, embedders are advised to get the engine handle by calling FlutterEngineInitialize. Then they can call FlutterEngineRunInitialized knowing that they will be able to service custom tasks on other threads with the engine handle.

Parameters

[in]	version	The Flutter embedder API version. Must be FLUTTER_ENGINE_VERSION.
[in]	config	The renderer configuration.
[in]	args	The Flutter project arguments.
	user_data	A user data baton passed back to embedders in callbacks.
[out]	engine_out	The engine handle on successful engine creation.

Returns: The result of the call to run the Flutter engine.

Definition at line 1971 of file embedder.cc.

                                                     {
  auto result =
      FlutterEngineInitialize(version, config, args, user_data, engine_out);
 
  if (result != kSuccess) {
    return result;
  }
 
  return FlutterEngineRunInitialized(*engine_out);
}

References args, FlutterEngineInitialize(), FlutterEngineRunInitialized(), kSuccess, and user_data.

Referenced by FlutterEngineGetProcAddresses(), main(), RunFlutter(), and RunFlutterEngine().

◆ FlutterEngineRunInitialized()

FLUTTER_EXPORT FlutterEngineResult FlutterEngineRunInitialized ( FLUTTER_API_SYMBOL(FlutterEngine) engine )

Runs an initialized engine instance. An engine can be initialized via FlutterEngineInitialize. An initialized instance can only be run once. During and after this call, custom task runners supplied by the embedder are expected to start servicing tasks.

Parameters

[in] engine An initialized engine instance that has not previously been run.

Returns: The result of the call to run the initialized Flutter engine instance.

Definition at line 2461 of file embedder.cc.

                                              {
  if (!engine) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Engine handle was invalid.");
  }
 
  auto embedder_engine = reinterpret_cast<flutter::EmbedderEngine*>(engine);
 
  // The engine must not already be running. Initialize may only be called
  // once on an engine instance.
  if (embedder_engine->IsValid()) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Engine handle was invalid.");
  }
 
  // Step 1: Launch the shell.
  if (!embedder_engine->LaunchShell()) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments,
                              "Could not launch the engine using supplied "
                              "initialization arguments.");
  }
 
  // Step 2: Tell the platform view to initialize itself.
  if (!embedder_engine->NotifyCreated()) {
    return LOG_EMBEDDER_ERROR(kInternalInconsistency,
                              "Could not create platform view components.");
  }
 
  // Step 3: Launch the root isolate.
  if (!embedder_engine->RunRootIsolate()) {
    return LOG_EMBEDDER_ERROR(
        kInvalidArguments,
        "Could not run the root isolate of the Flutter application using the "
        "project arguments specified.");
  }
 
  return kSuccess;
}

References engine, kInternalInconsistency, kInvalidArguments, kSuccess, and LOG_EMBEDDER_ERROR.

Referenced by FlutterEngineGetProcAddresses(), FlutterEngineRun(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), and flutter::testing::TEST_P().

◆ FlutterEngineRunsAOTCompiledDartCode()

FLUTTER_EXPORT bool FlutterEngineRunsAOTCompiledDartCode ( void )

Returns if the Flutter engine instance will run AOT compiled Dart code. This call has no threading restrictions.

For embedder code that is configured for both AOT and JIT mode Dart execution based on the Flutter engine being linked to, this runtime check may be used to appropriately configure the FlutterProjectArgs. In JIT mode execution, the kernel snapshots must be present in the Flutter assets directory specified in the FlutterProjectArgs. For AOT execution, the fields vm_snapshot_data, vm_snapshot_instructions, isolate_snapshot_data and isolate_snapshot_instructions (along with their size fields) must be specified in FlutterProjectArgs.

Returns: True, if AOT Dart code is run. JIT otherwise.

Definition at line 3424 of file embedder.cc.

                                                {
  return flutter::DartVM::IsRunningPrecompiledCode();
}

References flutter::DartVM::IsRunningPrecompiledCode().

Referenced by FlutterEngineGetProcAddresses(), RunFlutterEngine(), and flutter::testing::TEST_F().

◆ FlutterEngineRunTask()

FLUTTER_EXPORT FlutterEngineResult FlutterEngineRunTask	(	FLUTTER_API_SYMBOL(FlutterEngine)	engine,
		const FlutterTask *	task
	)

Inform the engine to run the specified task. This task has been given to the embedder via the FlutterTaskRunnerDescription.post_task_callback. This call must only be made at the target time specified in that callback. Running the task before that time is undefined behavior.

Parameters

[in]	engine	A running engine instance.
[in]	task	the task handle.

Returns: The result of the call.

Definition at line 3313 of file embedder.cc.

                                                                  {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Invalid engine handle.");
  }
 
  if (!flutter::EmbedderThreadHost::RunnerIsValid(
          reinterpret_cast<intptr_t>(task->runner))) {
    // This task came too late, the embedder has already been destroyed.
    // This is not an error, just ignore the task.
    return kSuccess;
  }
 
  return reinterpret_cast<flutter::EmbedderEngine*>(engine)->RunTask(task)
             ? kSuccess
             : LOG_EMBEDDER_ERROR(kInvalidArguments,
                                  "Could not run the specified task.");
}

References engine, kInvalidArguments, kSuccess, LOG_EMBEDDER_ERROR, FlutterTask::runner, and flutter::EmbedderThreadHost::RunnerIsValid().

Referenced by FlutterEngineGetProcAddresses(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), and flutter::testing::TEST_P().

◆ FlutterEngineScheduleFrame()

FLUTTER_EXPORT FlutterEngineResult FlutterEngineScheduleFrame ( FLUTTER_API_SYMBOL(FlutterEngine) engine )

Schedule a new frame to redraw the content.

Parameters

[in] engine A running engine instance.

Returns: the result of the call made to the engine.

Definition at line 3654 of file embedder.cc.

                                                           {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Invalid engine handle.");
  }
 
  return reinterpret_cast<flutter::EmbedderEngine*>(engine)->ScheduleFrame()
             ? kSuccess
             : LOG_EMBEDDER_ERROR(kInvalidArguments,
                                  "Could not schedule frame.");
}

References engine, kInvalidArguments, kSuccess, and LOG_EMBEDDER_ERROR.

Referenced by FlutterEngineGetProcAddresses(), and flutter::testing::TEST_F().

◆ FlutterEngineSendKeyEvent()

FLUTTER_EXPORT FlutterEngineResult FlutterEngineSendKeyEvent	(	FLUTTER_API_SYMBOL(FlutterEngine)	engine,
		const FlutterKeyEvent *	event,
		FlutterKeyEventCallback	callback,
		void *	user_data
	)

Sends a key event to the engine. The framework will decide whether to handle this event in a synchronous fashion, although due to technical limitation, the result is always reported asynchronously. The callback is guaranteed to be called exactly once.

Parameters

[in]	engine	A running engine instance.
[in]	event	The event data to be sent. This function will no longer access `event` after returning.
[in]	callback	The callback invoked by the engine when the Flutter application has decided whether it handles this event. Accepts nullptr.
[in]	user_data	The context associated with the callback. The exact same value will used to invoke `callback`. Accepts nullptr.

Returns: The result of the call.

Definition at line 2921 of file embedder.cc.

                                                               {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Engine handle was invalid.");
  }
 
  if (event == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Invalid key event.");
  }
 
  const char* character = SAFE_ACCESS(event, character, nullptr);
 
  flutter::KeyData key_data;
  key_data.Clear();
  key_data.timestamp = static_cast<uint64_t>(SAFE_ACCESS(event, timestamp, 0));
  key_data.type = MapKeyEventType(
      SAFE_ACCESS(event, type, FlutterKeyEventType::kFlutterKeyEventTypeUp));
  key_data.physical = SAFE_ACCESS(event, physical, 0);
  key_data.logical = SAFE_ACCESS(event, logical, 0);
  key_data.synthesized = SAFE_ACCESS(event, synthesized, false);
  key_data.device_type = MapKeyEventDeviceType(SAFE_ACCESS(
      event, device_type,
      FlutterKeyEventDeviceType::kFlutterKeyEventDeviceTypeKeyboard));
 
  auto packet = std::make_unique<flutter::KeyDataPacket>(key_data, character);
 
  struct MessageData {
    FlutterKeyEventCallback callback;
    void* user_data;
  };
 
  MessageData* message_data =
      new MessageData{.callback = callback, .user_data = user_data};
 
  // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
  return InternalSendPlatformMessage(
      engine, kFlutterKeyDataChannel, packet->data().data(),
      packet->data().size(),
      [](const uint8_t* data, size_t size, void* user_data) {
        auto message_data = std::unique_ptr<MessageData>(
            reinterpret_cast<MessageData*>(user_data));
        if (message_data->callback == nullptr) {
          return;
        }
        bool handled = false;
        if (size == 1) {
          handled = *data != 0;
        }
        message_data->callback(handled, message_data->user_data);
      },
      message_data);
}

References callback, character, flutter::KeyData::Clear(), data, flutter::KeyData::device_type, engine, InternalSendPlatformMessage(), kFlutterKeyDataChannel, kFlutterKeyEventDeviceTypeKeyboard, kFlutterKeyEventTypeUp, kInvalidArguments, LOG_EMBEDDER_ERROR, flutter::KeyData::logical, MapKeyEventDeviceType(), MapKeyEventType(), flutter::KeyData::physical, SAFE_ACCESS, flutter::KeyData::synthesized, flutter::KeyData::timestamp, type, flutter::KeyData::type, and user_data.

Referenced by FlutterEngineGetProcAddresses(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

◆ FlutterEngineSendPlatformMessage()

FLUTTER_EXPORT FlutterEngineResult FlutterEngineSendPlatformMessage	(	FLUTTER_API_SYMBOL(FlutterEngine)	engine,
		const FlutterPlatformMessage *	message
	)

Definition at line 2977 of file embedder.cc.

                                                   {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Invalid engine handle.");
  }
 
  if (flutter_message == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Invalid message argument.");
  }
 
  if (SAFE_ACCESS(flutter_message, channel, nullptr) == nullptr) {
    return LOG_EMBEDDER_ERROR(
        kInvalidArguments, "Message argument did not specify a valid channel.");
  }
 
  size_t message_size = SAFE_ACCESS(flutter_message, message_size, 0);
  const uint8_t* message_data = SAFE_ACCESS(flutter_message, message, nullptr);
 
  if (message_size != 0 && message_data == nullptr) {
    return LOG_EMBEDDER_ERROR(
        kInvalidArguments,
        "Message size was non-zero but the message data was nullptr.");
  }
 
  const FlutterPlatformMessageResponseHandle* response_handle =
      SAFE_ACCESS(flutter_message, response_handle, nullptr);
 
  fml::RefPtr<flutter::PlatformMessageResponse> response;
  if (response_handle && response_handle->message) {
    response = response_handle->message->response();
  }
 
  std::unique_ptr<flutter::PlatformMessage> message;
  if (message_size == 0) {
    message = std::make_unique<flutter::PlatformMessage>(
        flutter_message->channel, response);
  } else {
    message = std::make_unique<flutter::PlatformMessage>(
        flutter_message->channel,
        fml::MallocMapping::Copy(message_data, message_size), response);
  }
 
  return reinterpret_cast<flutter::EmbedderEngine*>(engine)
                 ->SendPlatformMessage(std::move(message))
             ? kSuccess
             : LOG_EMBEDDER_ERROR(kInternalInconsistency,
                                  "Could not send a message to the running "
                                  "Flutter application.");
}

References FlutterPlatformMessage::channel, channel, fml::MallocMapping::Copy(), engine, kInternalInconsistency, kInvalidArguments, kSuccess, LOG_EMBEDDER_ERROR, _FlutterPlatformMessageResponseHandle::message, message, and SAFE_ACCESS.

Referenced by FlutterDesktopMessengerSendWithReply(), FlutterEngineGetProcAddresses(), InternalSendPlatformMessage(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

◆ FlutterEngineSendPlatformMessageResponse()

FLUTTER_EXPORT FlutterEngineResult FlutterEngineSendPlatformMessageResponse	(	FLUTTER_API_SYMBOL(FlutterEngine)	engine,
		const FlutterPlatformMessageResponseHandle *	handle,
		const uint8_t *	data,
		size_t	data_length
	)

Send a response from the native side to a platform message from the Dart Flutter application.

Parameters

[in]	engine	The running engine instance.
[in]	handle	The platform message response handle.
[in]	data	The data to associate with the platform message response.
[in]	data_length	The length of the platform message response data.

Returns: The result of the call.

Definition at line 3078 of file embedder.cc.

                        {
  if (data_length != 0 && data == nullptr) {
    return LOG_EMBEDDER_ERROR(
        kInvalidArguments,
        "Data size was non zero but the pointer to the data was null.");
  }
 
  auto response = handle->message->response();
 
  if (response) {
    if (data_length == 0) {
      response->CompleteEmpty();
    } else {
      response->Complete(std::make_unique<fml::DataMapping>(
          std::vector<uint8_t>({data, data + data_length})));
    }
  }
 
  delete handle;
 
  return kSuccess;
}

References data, kInvalidArguments, kSuccess, LOG_EMBEDDER_ERROR, and _FlutterPlatformMessageResponseHandle::message.

Referenced by FlutterDesktopMessengerSendResponse(), FlutterEngineGetProcAddresses(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

◆ FlutterEngineSendPointerEvent()

FLUTTER_EXPORT FlutterEngineResult FlutterEngineSendPointerEvent	(	FLUTTER_API_SYMBOL(FlutterEngine)	engine,
		const FlutterPointerEvent *	events,
		size_t	events_count
	)

Definition at line 2769 of file embedder.cc.

                         {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Engine handle was invalid.");
  }
 
  if (pointers == nullptr || events_count == 0) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Invalid pointer events.");
  }
 
  auto packet = std::make_unique<flutter::PointerDataPacket>(events_count);
 
  const FlutterPointerEvent* current = pointers;
 
  for (size_t i = 0; i < events_count; ++i) {
    flutter::PointerData pointer_data;
    pointer_data.Clear();
    // this is currely in use only on android embedding.
    pointer_data.embedder_id = 0;
    pointer_data.time_stamp = SAFE_ACCESS(current, timestamp, 0);
    pointer_data.change = ToPointerDataChange(
        SAFE_ACCESS(current, phase, FlutterPointerPhase::kCancel));
    pointer_data.physical_x = SAFE_ACCESS(current, x, 0.0);
    pointer_data.physical_y = SAFE_ACCESS(current, y, 0.0);
    // Delta will be generated in pointer_data_packet_converter.cc.
    pointer_data.physical_delta_x = 0.0;
    pointer_data.physical_delta_y = 0.0;
    pointer_data.device = SAFE_ACCESS(current, device, 0);
    // Pointer identifier will be generated in
    // pointer_data_packet_converter.cc.
    pointer_data.pointer_identifier = 0;
    pointer_data.signal_kind = ToPointerDataSignalKind(
        SAFE_ACCESS(current, signal_kind, kFlutterPointerSignalKindNone));
    pointer_data.scroll_delta_x = SAFE_ACCESS(current, scroll_delta_x, 0.0);
    pointer_data.scroll_delta_y = SAFE_ACCESS(current, scroll_delta_y, 0.0);
    FlutterPointerDeviceKind device_kind =
        SAFE_ACCESS(current, device_kind, kFlutterPointerDeviceKindMouse);
    // For backwards compatibility with embedders written before the device
    // kind and buttons were exposed, if the device kind is not set treat it
    // as a mouse, with a synthesized primary button state based on the phase.
    if (device_kind == 0) {
      pointer_data.kind = flutter::PointerData::DeviceKind::kMouse;
      pointer_data.buttons =
          PointerDataButtonsForLegacyEvent(pointer_data.change);
 
    } else {
      pointer_data.kind = ToPointerDataKind(device_kind);
      if (pointer_data.kind == flutter::PointerData::DeviceKind::kTouch) {
        // For touch events, set the button internally rather than requiring
        // it at the API level, since it's a confusing construction to expose.
        if (pointer_data.change == flutter::PointerData::Change::kDown ||
            pointer_data.change == flutter::PointerData::Change::kMove) {
          pointer_data.buttons = flutter::kPointerButtonTouchContact;
        }
      } else {
        // Buttons use the same mask values, so pass them through directly.
        pointer_data.buttons = SAFE_ACCESS(current, buttons, 0);
      }
    }
    pointer_data.pan_x = SAFE_ACCESS(current, pan_x, 0.0);
    pointer_data.pan_y = SAFE_ACCESS(current, pan_y, 0.0);
    // Delta will be generated in pointer_data_packet_converter.cc.
    pointer_data.pan_delta_x = 0.0;
    pointer_data.pan_delta_y = 0.0;
    pointer_data.scale = SAFE_ACCESS(current, scale, 0.0);
    pointer_data.rotation = SAFE_ACCESS(current, rotation, 0.0);
    pointer_data.view_id =
        SAFE_ACCESS(current, view_id, kFlutterImplicitViewId);
    packet->SetPointerData(i, pointer_data);
    current = reinterpret_cast<const FlutterPointerEvent*>(
        reinterpret_cast<const uint8_t*>(current) + current->struct_size);
  }
 
  return reinterpret_cast<flutter::EmbedderEngine*>(engine)
                 ->DispatchPointerDataPacket(std::move(packet))
             ? kSuccess
             : LOG_EMBEDDER_ERROR(kInternalInconsistency,
                                  "Could not dispatch pointer events to the "
                                  "running Flutter application.");
}

Referenced by FlutterEngineGetProcAddresses(), GLFWcursorPositionCallbackAtPhase(), SendPointerEventWithData(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

◆ FlutterEngineSendSemanticsAction()

FLUTTER_EXPORT FlutterEngineResult FlutterEngineSendSemanticsAction	(	FLUTTER_API_SYMBOL(FlutterEngine)	engine,
		const FlutterSendSemanticsActionInfo *	info
	)

Dispatch a semantics action to the specified semantics node within a specific view.

Parameters

[in]	engine	A running engine instance.
[in]	info	The dispatch semantics on view arguments. This can be deallocated once \|FlutterEngineSendSemanticsAction\| returns.

Returns: The result of the call.

Definition at line 3212 of file embedder.cc.

                                                {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Invalid engine handle.");
  }
  auto engine_action = static_cast<flutter::SemanticsAction>(info->action);
  if (!reinterpret_cast<flutter::EmbedderEngine*>(engine)
           ->DispatchSemanticsAction(
               info->view_id, info->node_id, engine_action,
               fml::MallocMapping::Copy(info->data, info->data_length))) {
    return LOG_EMBEDDER_ERROR(kInternalInconsistency,
                              "Could not dispatch semantics action.");
  }
  return kSuccess;
}

References FlutterSendSemanticsActionInfo::action, fml::MallocMapping::Copy(), FlutterSendSemanticsActionInfo::data, FlutterSendSemanticsActionInfo::data_length, flutter::EmbedderEngine::DispatchSemanticsAction(), engine, kInternalInconsistency, kInvalidArguments, kSuccess, LOG_EMBEDDER_ERROR, FlutterSendSemanticsActionInfo::node_id, and FlutterSendSemanticsActionInfo::view_id.

Referenced by FlutterEngineDispatchSemanticsAction(), and FlutterEngineGetProcAddresses().

◆ FlutterEngineSendViewFocusEvent()

FLUTTER_EXPORT FlutterEngineResult FlutterEngineSendViewFocusEvent	(	FLUTTER_API_SYMBOL(FlutterEngine)	engine,
		const FlutterViewFocusEvent *	event
	)

Notifies the engine that platform view focus state has changed.

Parameters

[in]	engine	A running engine instance
[in]	event	The focus event data describing the change.

Definition at line 2603 of file embedder.cc.

                                        {
  if (!engine) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Engine handle was invalid.");
  }
  if (!event) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments,
                              "View focus event must not be null.");
  }
  // The engine must be running to focus a view.
  auto embedder_engine = reinterpret_cast<flutter::EmbedderEngine*>(engine);
  if (!embedder_engine->IsValid()) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Engine handle was invalid.");
  }
 
  if (!STRUCT_HAS_MEMBER(event, direction)) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments,
                              "The event struct has invalid size.");
  }
 
  flutter::ViewFocusEvent flutter_event(
      event->view_id,  //
      static_cast<flutter::ViewFocusState>(event->state),
      static_cast<flutter::ViewFocusDirection>(event->direction));
 
  embedder_engine->GetShell().GetPlatformView()->SendViewFocusEvent(
      flutter_event);
 
  return kSuccess;
}

References FlutterViewFocusEvent::direction, engine, kInvalidArguments, kSuccess, LOG_EMBEDDER_ERROR, FlutterViewFocusEvent::state, STRUCT_HAS_MEMBER, and FlutterViewFocusEvent::view_id.

Referenced by FlutterEngineGetProcAddresses(), and flutter::testing::TEST_F().

◆ FlutterEngineSendWindowMetricsEvent()

FLUTTER_EXPORT FlutterEngineResult FlutterEngineSendWindowMetricsEvent	(	FLUTTER_API_SYMBOL(FlutterEngine)	engine,
		const FlutterWindowMetricsEvent *	event
	)

Definition at line 2660 of file embedder.cc.

                                                      {
  if (engine == nullptr || flutter_metrics == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Engine handle was invalid.");
  }
  FlutterViewId view_id =
      SAFE_ACCESS(flutter_metrics, view_id, kFlutterImplicitViewId);
 
  std::variant<flutter::ViewportMetrics, std::string> metrics_or_error =
      MakeViewportMetricsFromWindowMetrics(flutter_metrics);
  if (const std::string* error = std::get_if<std::string>(&metrics_or_error)) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, error->c_str());
  }
 
  auto metrics = std::get<flutter::ViewportMetrics>(metrics_or_error);
 
  return reinterpret_cast<flutter::EmbedderEngine*>(engine)->SetViewportMetrics(
             view_id, metrics)
             ? kSuccess
             : LOG_EMBEDDER_ERROR(kInvalidArguments,
                                  "Viewport metrics were invalid.");
}

References engine, error, kFlutterImplicitViewId, kInvalidArguments, kSuccess, LOG_EMBEDDER_ERROR, MakeViewportMetricsFromWindowMetrics(), SAFE_ACCESS, and view_id.

◆ FlutterEngineSetNextFrameCallback()

FLUTTER_EXPORT FlutterEngineResult FlutterEngineSetNextFrameCallback	(	FLUTTER_API_SYMBOL(FlutterEngine)	engine,
		VoidCallback	callback,
		void *	user_data
	)

Schedule a callback to be called after the next frame is drawn. This must be called from the platform thread. The callback is executed only once from the raster thread; embedders must re-thread if necessary. Performing blocking calls in this callback may introduce application jank.

Parameters

[in]	engine	A running engine instance.
[in]	callback	The callback to execute.
[in]	user_data	A baton passed by the engine to the callback. This baton is not interpreted by the engine in any way.

Returns: The result of the call.

Definition at line 3666 of file embedder.cc.

                     {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Invalid engine handle.");
  }
 
  if (callback == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments,
                              "Next frame callback was null.");
  }
 
  flutter::EmbedderEngine* embedder_engine =
      reinterpret_cast<flutter::EmbedderEngine*>(engine);
 
  fml::WeakPtr<flutter::PlatformView> weak_platform_view =
      embedder_engine->GetShell().GetPlatformView();
 
  if (!weak_platform_view) {
    return LOG_EMBEDDER_ERROR(kInternalInconsistency,
                              "Platform view unavailable.");
  }
 
  weak_platform_view->SetNextFrameCallback(
      [callback, user_data]() { callback(user_data); });
 
  return kSuccess;
}

References callback, engine, flutter::Shell::GetPlatformView(), flutter::EmbedderEngine::GetShell(), kInternalInconsistency, kInvalidArguments, kSuccess, LOG_EMBEDDER_ERROR, and user_data.

Referenced by FlutterEngineGetProcAddresses(), and flutter::testing::TEST_F().

◆ FlutterEngineShutdown()

FLUTTER_EXPORT FlutterEngineResult FlutterEngineShutdown ( FLUTTER_API_SYMBOL(FlutterEngine) engine )

Shuts down a Flutter engine instance. The engine handle is no longer valid for any calls in the embedder API after this point. Making additional calls with this handle is undefined behavior.

Note: This de-initializes the Flutter engine instance (via an implicit call to FlutterEngineDeinitialize) if necessary.

Parameters

[in] engine The Flutter engine instance to collect.

Returns: The result of the call to shutdown the Flutter engine instance.

Definition at line 2649 of file embedder.cc.

                                                      {
  auto result = FlutterEngineDeinitialize(engine);
  if (result != kSuccess) {
    return result;
  }
  auto embedder_engine = reinterpret_cast<flutter::EmbedderEngine*>(engine);
  delete embedder_engine;
  return kSuccess;
}

References engine, FlutterEngineDeinitialize(), and kSuccess.

Referenced by FlutterDesktopDestroyWindow(), FlutterDesktopShutDownEngine(), FlutterEngineGetProcAddresses(), flutter::testing::UniqueEngineTraits::Free(), main(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

◆ FlutterEngineTraceEventDurationBegin()

FLUTTER_EXPORT void FlutterEngineTraceEventDurationBegin ( const char * name )

A profiling utility. Logs a trace duration begin event to the timeline. If the timeline is unavailable or disabled, this has no effect. Must be balanced with an duration end event (via FlutterEngineTraceEventDurationEnd) with the same name on the same thread. Can be called on any thread. Strings passed into the function will NOT be copied when added to the timeline. Only string literals may be passed in.

Parameters

[in] name The name of the trace event.

Definition at line 3273 of file embedder.cc.

                                                            {
  fml::tracing::TraceEvent0("flutter", name, /*flow_id_count=*/0,
                            /*flow_ids=*/nullptr);
}

References name, and fml::tracing::TraceEvent0().

Referenced by FlutterEngineGetProcAddresses().

◆ FlutterEngineTraceEventDurationEnd()

FLUTTER_EXPORT void FlutterEngineTraceEventDurationEnd ( const char * name )

A profiling utility. Logs a trace duration end event to the timeline. If the timeline is unavailable or disabled, this has no effect. This call must be preceded by a trace duration begin call (via FlutterEngineTraceEventDurationBegin) with the same name on the same thread. Can be called on any thread. Strings passed into the function will NOT be copied when added to the timeline. Only string literals may be passed in.

Parameters

[in] name The name of the trace event.

Definition at line 3278 of file embedder.cc.

                                                          {
  fml::tracing::TraceEventEnd(name);
}

References name, and fml::tracing::TraceEventEnd().

Referenced by FlutterEngineGetProcAddresses().

◆ FlutterEngineTraceEventInstant()

FLUTTER_EXPORT void FlutterEngineTraceEventInstant ( const char * name )

A profiling utility. Logs a trace duration instant event to the timeline. If the timeline is unavailable or disabled, this has no effect. Can be called on any thread. Strings passed into the function will NOT be copied when added to the timeline. Only string literals may be passed in.

Parameters

[in] name The name of the trace event.

Definition at line 3282 of file embedder.cc.

                                                      {
  fml::tracing::TraceEventInstant0("flutter", name, /*flow_id_count=*/0,
                                   /*flow_ids=*/nullptr);
}

References name, and fml::tracing::TraceEventInstant0().

Referenced by FlutterEngineGetProcAddresses().

◆ FlutterEngineUnregisterExternalTexture()

FLUTTER_EXPORT FlutterEngineResult FlutterEngineUnregisterExternalTexture	(	FLUTTER_API_SYMBOL(FlutterEngine)	engine,
		int64_t	texture_identifier
	)

Unregister a previous texture registration.

See also: FlutterEngineRegisterExternalTexture(); FlutterEngineMarkExternalTextureFrameAvailable()

Parameters

[in]	engine	A running engine instance.
[in]	texture_identifier	The identifier of the texture for which new frame will not be available.

Returns: The result of the call.

Definition at line 3129 of file embedder.cc.

                                {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Engine handle was invalid.");
  }
 
  if (texture_identifier == 0) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments,
                              "Texture identifier was invalid.");
  }
 
  if (!reinterpret_cast<flutter::EmbedderEngine*>(engine)->UnregisterTexture(
          texture_identifier)) {
    return LOG_EMBEDDER_ERROR(kInternalInconsistency,
                              "Could not un-register the specified texture.");
  }
 
  return kSuccess;
}

References engine, kInternalInconsistency, kInvalidArguments, kSuccess, and LOG_EMBEDDER_ERROR.

Referenced by FlutterEngineGetProcAddresses().

◆ FlutterEngineUpdateAccessibilityFeatures()

FLUTTER_EXPORT FlutterEngineResult FlutterEngineUpdateAccessibilityFeatures	(	FLUTTER_API_SYMBOL(FlutterEngine)	engine,
		FlutterAccessibilityFeature	features
	)

Sets additional accessibility features.

Parameters

[in]	engine	A running engine instance
[in]	features	The accessibility features to set.

Returns: The result of the call.

Definition at line 3182 of file embedder.cc.

                                       {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Invalid engine handle.");
  }
  if (!reinterpret_cast<flutter::EmbedderEngine*>(engine)
           ->SetAccessibilityFeatures(flags)) {
    return LOG_EMBEDDER_ERROR(kInternalInconsistency,
                              "Could not update accessibility features.");
  }
  return kSuccess;
}

References engine, kInternalInconsistency, kInvalidArguments, kSuccess, and LOG_EMBEDDER_ERROR.

Referenced by FlutterEngineGetProcAddresses(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

◆ FlutterEngineUpdateLocales()

FLUTTER_EXPORT FlutterEngineResult FlutterEngineUpdateLocales	(	FLUTTER_API_SYMBOL(FlutterEngine)	engine,
		const FlutterLocale **	locales,
		size_t	locales_count
	)

Notify a running engine instance that the locale has been updated. The preferred locale must be the first item in the list of locales supplied. The other entries will be used as a fallback.

Parameters

[in]	engine	A running engine instance.
[in]	locales	The updated locales in the order of preference.
[in]	locales_count	The count of locales supplied.

Returns: Whether the locale updates were applied.

Definition at line 3365 of file embedder.cc.

                                                                     {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Invalid engine handle.");
  }
 
  if (locales_count == 0) {
    return kSuccess;
  }
 
  if (locales == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "No locales were specified.");
  }
 
  rapidjson::Document document;
  auto& allocator = document.GetAllocator();
 
  document.SetObject();
  document.AddMember("method", "setLocale", allocator);
 
  rapidjson::Value args(rapidjson::kArrayType);
  args.Reserve(locales_count * 4, allocator);
  for (size_t i = 0; i < locales_count; ++i) {
    const FlutterLocale* locale = locales[i];
    const char* language_code_str = SAFE_ACCESS(locale, language_code, nullptr);
    if (language_code_str == nullptr || ::strlen(language_code_str) == 0) {
      return LOG_EMBEDDER_ERROR(
          kInvalidArguments,
          "Language code is required but not present in FlutterLocale.");
    }
 
    const char* country_code_str = SAFE_ACCESS(locale, country_code, "");
    const char* script_code_str = SAFE_ACCESS(locale, script_code, "");
    const char* variant_code_str = SAFE_ACCESS(locale, variant_code, "");
 
    rapidjson::Value language_code, country_code, script_code, variant_code;
 
    language_code.SetString(language_code_str, allocator);
    country_code.SetString(country_code_str ? country_code_str : "", allocator);
    script_code.SetString(script_code_str ? script_code_str : "", allocator);
    variant_code.SetString(variant_code_str ? variant_code_str : "", allocator);
 
    // Required.
    args.PushBack(language_code, allocator);
    args.PushBack(country_code, allocator);
    args.PushBack(script_code, allocator);
    args.PushBack(variant_code, allocator);
  }
  document.AddMember("args", args, allocator);
 
  return DispatchJSONPlatformMessage(engine, document, "flutter/localization")
             ? kSuccess
             : LOG_EMBEDDER_ERROR(kInternalInconsistency,
                                  "Could not send message to update locale of "
                                  "a running Flutter application.");
}

References args, DispatchJSONPlatformMessage(), engine, i, kInternalInconsistency, kInvalidArguments, kSuccess, LOG_EMBEDDER_ERROR, and SAFE_ACCESS.

Referenced by FlutterEngineGetProcAddresses(), SetUpLocales(), and flutter::testing::TEST_F().

◆ FlutterEngineUpdateSemanticsEnabled()

FLUTTER_EXPORT FlutterEngineResult FlutterEngineUpdateSemanticsEnabled	(	FLUTTER_API_SYMBOL(FlutterEngine)	engine,
		bool	enabled
	)

Enable or disable accessibility semantics.

Parameters

[in]	engine	A running engine instance.
[in]	enabled	When enabled, changes to the semantic contents of the window are sent via the `FlutterUpdateSemanticsCallback2` registered to `update_semantics_callback2` in `FlutterProjectArgs`.

Returns: The result of the call.

Definition at line 3168 of file embedder.cc.

                  {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Invalid engine handle.");
  }
  if (!reinterpret_cast<flutter::EmbedderEngine*>(engine)->SetSemanticsEnabled(
          enabled)) {
    return LOG_EMBEDDER_ERROR(kInternalInconsistency,
                              "Could not update semantics state.");
  }
  return kSuccess;
}

References engine, kInternalInconsistency, kInvalidArguments, kSuccess, and LOG_EMBEDDER_ERROR.

Referenced by FlutterEngineGetProcAddresses(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

◆ FlutterPlatformMessageCreateResponseHandle()

FLUTTER_EXPORT FlutterEngineResult FlutterPlatformMessageCreateResponseHandle	(	FLUTTER_API_SYMBOL(FlutterEngine)	engine,
		FlutterDataCallback	data_callback,
		void *	user_data,
		FlutterPlatformMessageResponseHandle **	response_out
	)

Creates a platform message response handle that allows the embedder to set a native callback for a response to a message. This handle may be set on the response_handle field of any FlutterPlatformMessage sent to the engine.

The handle must be collected via a call to FlutterPlatformMessageReleaseResponseHandle. This may be done immediately after a call to FlutterEngineSendPlatformMessage with a platform message whose response handle contains the handle created using this call. In case a handle is created but never sent in a message, the release call must still be made. Not calling release on the handle results in a small memory leak.

The user data baton passed to the data callback is the one specified in this call as the third argument.

See also: FlutterPlatformMessageReleaseResponseHandle()

Parameters

[in]	engine	A running engine instance.
[in]	data_callback	The callback invoked by the engine when the Flutter application send a response on the handle.
[in]	user_data	The user data associated with the data callback.
[out]	response_out	The response handle created when this call is successful.

Returns: The result of the call.

Definition at line 3028 of file embedder.cc.

                                                         {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Engine handle was invalid.");
  }
 
  if (data_callback == nullptr || response_out == nullptr) {
    return LOG_EMBEDDER_ERROR(
        kInvalidArguments, "Data callback or the response handle was invalid.");
  }
 
  flutter::EmbedderPlatformMessageResponse::Callback response_callback =
      [user_data, data_callback](const uint8_t* data, size_t size) {
        data_callback(data, size, user_data);
      };
 
  auto platform_task_runner = reinterpret_cast<flutter::EmbedderEngine*>(engine)
                                  ->GetTaskRunners()
                                  .GetPlatformTaskRunner();
 
  auto handle = new FlutterPlatformMessageResponseHandle();
 
  handle->message = std::make_unique<flutter::PlatformMessage>(
      "",  // The channel is empty and unused as the response handle is going
           // to referenced directly in the |FlutterEngineSendPlatformMessage|
           // with the container message discarded.
      fml::MakeRefCounted<flutter::EmbedderPlatformMessageResponse>(
          std::move(platform_task_runner), response_callback));
  *response_out = handle;
  return kSuccess;
}

References data, engine, kInvalidArguments, kSuccess, LOG_EMBEDDER_ERROR, and user_data.

Referenced by FlutterDesktopMessengerSendWithReply(), FlutterEngineGetProcAddresses(), InternalSendPlatformMessage(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

◆ FlutterPlatformMessageReleaseResponseHandle()

FLUTTER_EXPORT FlutterEngineResult FlutterPlatformMessageReleaseResponseHandle	(	FLUTTER_API_SYMBOL(FlutterEngine)	engine,
		FlutterPlatformMessageResponseHandle *	response
	)

Collects the handle created using FlutterPlatformMessageCreateResponseHandle.

See also: FlutterPlatformMessageCreateResponseHandle()

Parameters

[in]	engine	A running engine instance.
[in]	response	The platform message response handle to collect. These handles are created using `FlutterPlatformMessageCreateResponseHandle()`.

Returns: The result of the call.

Definition at line 3063 of file embedder.cc.

                                                    {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Invalid engine handle.");
  }
 
  if (response == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, "Invalid response handle.");
  }
  delete response;
  return kSuccess;
}

References engine, kInvalidArguments, kSuccess, and LOG_EMBEDDER_ERROR.

Referenced by FlutterDesktopMessengerSendWithReply(), FlutterEngineGetProcAddresses(), InternalSendPlatformMessage(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

Variable Documentation

◆ kFlutterSemanticsCustomActionIdBatchEnd

FLUTTER_EXPORT const int32_t kFlutterSemanticsCustomActionIdBatchEnd

extern

FlutterSemanticsCustomAction ID used as a sentinel to signal the end of a batch of semantics custom action updates. This is unused if using FlutterUpdateSemanticsCallback2.

Definition at line 108 of file embedder.cc.

Referenced by CreateEmbedderSemanticsUpdateCallbackV1(), and flutter::testing::TEST_F().

◆ kFlutterSemanticsNodeIdBatchEnd

FLUTTER_EXPORT const int32_t kFlutterSemanticsNodeIdBatchEnd

extern

FlutterSemanticsNode ID used as a sentinel to signal the end of a batch of semantics node updates. This is unused if using FlutterUpdateSemanticsCallback2.

Definition at line 107 of file embedder.cc.

Referenced by CreateEmbedderSemanticsUpdateCallbackV1(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ FLUTTER_API_SYMBOL

◆ FLUTTER_ENGINE_VERSION

◆ FLUTTER_EXPORT

Typedef Documentation

◆ BoolCallback

◆ BoolPresentInfoCallback

◆ FLUTTER_API_SYMBOL

◆ FlutterAddViewCallback

◆ FlutterBackingStoreCollectCallback

◆ FlutterBackingStoreCreateCallback

◆ FlutterChannelUpdateCallback

◆ FlutterComputePlatformResolvedLocaleCallback

◆ FlutterDataCallback

◆ FlutterEngineAddViewFnPtr

◆ FlutterEngineAOTData

◆ FlutterEngineCollectAOTDataFnPtr

◆ FlutterEngineCreateAOTDataFnPtr

◆ FlutterEngineDartPort

◆ FlutterEngineDeinitializeFnPtr

◆ FlutterEngineDispatchSemanticsActionFnPtr

◆ FlutterEngineDisplayId

◆ FlutterEngineGetCurrentTimeFnPtr

◆ FlutterEngineInitializeFnPtr

◆ FlutterEngineMarkExternalTextureFrameAvailableFnPtr

◆ FlutterEngineNotifyDisplayUpdateFnPtr

◆ FlutterEngineNotifyLowMemoryWarningFnPtr

◆ FlutterEngineOnVsyncFnPtr

◆ FlutterEnginePlatformMessageCreateResponseHandleFnPtr

◆ FlutterEnginePlatformMessageReleaseResponseHandleFnPtr

◆ FlutterEnginePostCallbackOnAllNativeThreadsFnPtr

◆ FlutterEnginePostDartObjectFnPtr

◆ FlutterEnginePostRenderThreadTaskFnPtr

◆ FlutterEngineRegisterExternalTextureFnPtr

◆ FlutterEngineReloadSystemFontsFnPtr

◆ FlutterEngineRemoveViewFnPtr

◆ FlutterEngineRunFnPtr

◆ FlutterEngineRunInitializedFnPtr

◆ FlutterEngineRunsAOTCompiledDartCodeFnPtr

◆ FlutterEngineRunTaskFnPtr

◆ FlutterEngineScheduleFrameFnPtr

◆ FlutterEngineSendKeyEventFnPtr

◆ FlutterEngineSendPlatformMessageFnPtr

◆ FlutterEngineSendPlatformMessageResponseFnPtr

◆ FlutterEngineSendPointerEventFnPtr

◆ FlutterEngineSendSemanticsActionFnPtr

◆ FlutterEngineSendViewFocusEventFnPtr

◆ FlutterEngineSendWindowMetricsEventFnPtr

◆ FlutterEngineSetNextFrameCallbackFnPtr

◆ FlutterEngineShutdownFnPtr

◆ FlutterEngineTraceEventDurationBeginFnPtr

◆ FlutterEngineTraceEventDurationEndFnPtr

◆ FlutterEngineTraceEventInstantFnPtr

◆ FlutterEngineUnregisterExternalTextureFnPtr

◆ FlutterEngineUpdateAccessibilityFeaturesFnPtr

◆ FlutterEngineUpdateLocalesFnPtr

◆ FlutterEngineUpdateSemanticsEnabledFnPtr

◆ FlutterFrameBufferWithDamageCallback

◆ FlutterKeyEventCallback

◆ FlutterLayersPresentCallback

◆ FlutterLogMessageCallback

◆ FlutterMetalCommandQueueHandle

◆ FlutterMetalDeviceHandle

◆ FlutterMetalPresentCallback

◆ FlutterMetalTextureCallback

◆ FlutterMetalTextureFrameCallback

◆ FlutterMetalTextureHandle

◆ FlutterNativeThreadCallback

◆ FlutterOpenGLSurfaceCallback

◆ FlutterPlatformMessageCallback

◆ FlutterPlatformMessageResponseHandle

◆ FlutterPlatformViewIdentifier

◆ FlutterPresentViewCallback

◆ FlutterRemoveViewCallback