fuchsia.ui.composition

PROTOCOLS

Allocator

Defined in fuchsia.ui.composition/allocator.fidl

RegisterBufferCollection

A BufferCollection is a set of VMOs created by Sysmem and shared by a number of participants, one of which is the Flatland Renderer. Some content, such as Images, use a BufferCollection as their backing memory.

See RegisterBufferCollectionArgs for information on each argument.

Request

NameType
args RegisterBufferCollectionArgs

Response

NameType
result Allocator_RegisterBufferCollection_Result

ChildViewWatcher

Defined in fuchsia.ui.composition/flatland.fidl

A protocol that provides information about a particular child View which is attached to the Viewport owned by the parent client; connections to this protocol are estabished in CreateViewport. Since a Flatland instance may contain any number of Viewports, each of which may or may not be attached to a transform, the client can maintain connections to an equal number of ChildViewWatcher instances.

Each ChildViewWatcher instance will remain connected as long as the corresponding child View exists; the connection will also be closed if the child's ViewCreationToken is dropped without using it to create a View.

GetStatus

A hanging get for receiving the status of a View. This provides information to the parent, such as whether or not the child has successfully presented content through this View.

This hanging get will only fire when the ChildViewStatus is different than the previously returned ChildViewStatus. This can happen immediately, and even if the creator of the Viewport hasn't yet called Present() after calling CreateViewport(). This allows the parent to know that the child has content ready to display before the parent modifies their own local scene graph to incorporate the child content.

It is invalid to call GetStatus while a previous call is still pending. Doing so will cause both this channel and the Flatland channel that handed out ChildViewWatcher to be closed.

Request

<EMPTY>

Response

NameType
status ChildViewStatus

GetViewRef

Hanging get to receive the ViewRef of the child View. This will only fire when the View ref is different from the previously-returned View ref. Note: currently the View ref will not change after it is first received, but this will change if/when the API changes to allow relinking of views.

The ViewRef is not returned until the View is included in the View tree, in other words when there is a chain of ancestor transforms all the way back up to the root of the scene graph, i.e. the display.

It is invalid to call GetViewRef while a previous call is still pending. Doing so will cause both this channel and the Flatland channel that handed out ChildViewWatcher to be closed.

Request

<EMPTY>

Response

NameType
view_ref fuchsia.ui.views/ViewRef

Flatland

Defined in fuchsia.ui.composition/flatland.fidl

Each Flatland instance contains a Graph, which consists of a set of objects, and the relationships between those objects. The client can specify a subset of those objects (specifically, the directed acyclic graph starting at the root transform) to be presented as content to some kind of output -- usually, a display.

Flatland Graphs are both hierarchical, and distributed. Graphs from different Flatland instances may be connected together, allowing multiple processes to be involved in authoring content for a particular output.

All functions in this protocol are feed-forward. The operations they represent are not fully executed until Present is called.

AddChild

Adds a child Transform to a parent Transform. The new child Transform, and any Content attached to it or its children, will be rendered on top of the parent's Content, as well as any previously added children.

Request

NameType
parent_transform_id TransformId
child_transform_id TransformId

Clear

This function will reset all state on this interface. This includes destroying all existing View and Viewports without returning the associated Token to the caller.

Request

<EMPTY>

CreateFilledRect

Creates a solid-color rectangle. By default a filled-rect does not have a defined color or size. It is necessary to call |SetSolidFill| to specify a color and size before a filled rect can be used for rendering. Not doing so will result the

Request

NameType
rect_id ContentId

CreateImage

An Image is a bitmap backed by a specific VMO in a BufferCollection.

Image creation requires an allocated BufferCollection registered with Allocator. This function will fail unless all clients of the specified BufferCollection have set their constraints.

The Image must reference a valid VMO index and must have ImageProperties that fall within the constraints specified by the backing BufferCollection (i.e. width and height within a valid range, etc.)

Zero is not a valid Image id. All other values are valid, assuming they are not already in use for another piece of Content (see ReleaseImage for more details).

Request

NameType
image_id ContentId
import_token BufferCollectionImportToken
vmo_index uint32
properties ImageProperties

CreateTransform

Creates a new Transform node. Transforms are a hierarchical piece of a Flatland graph. They can have children, and can reference Content. A sub-graph represented by a Transform and its descendants can be rendered to a display.

Transforms are kept alive, even when released, as long as they are children of either an unreleased Transform, or the Root Transform.

Each Transform can have a single piece of attached Content. Common types of Content include bitmaps, asynchronous streams of images, and Viewports to Views hosted in other Flatland instances.

Transforms have attributes. Child Transforms inherit the combined attributes of their parents. Content attached to a Transform is also affected by that Transform's attributes.

When a sub-graph of Transforms is rendered, Content will be rendered back-to-front, starting with the Content on the root transform, and continuing recursively through all of its child Transforms in the order the children were added. See AddChild for more information.

Zero is not a valid transform id. All other values are valid, assuming they are not already in use (see ReleaseTransform for more details).

Request

NameType
transform_id TransformId

CreateView

Two Flatland instances may be connected in a parent-child relationship. The parent endpoint is held in a Viewport, and the child endpoint is held in a View. The parent Flatland instance that creates a Viewport has control over how the child's View is integrated into its own View.

The lifecycle of a parent-child connection starts with two endpoints of a channel object: a ViewportCreationToken and a ViewCreationToken. Out-of-band protocols pass the ViewportCreationToken to the parent, which calls CreateViewport, and the ViewCreationToken to the child, which calls CreateView.

Only nodes connected to the Root Transform in this Flatland instance will be rendered into the parent's Viewport.

Calling CreateView a second time will disconnect the Root Transform from the existing parent's Viewport, and attach it to a new parent's Viewport. In other words, each View can only have one parent.

This function is queued, meaning that the Root Transform will not be attached to the parent Viewport until Present is called. However, clients will receive information through their ParentViewportWatcher (e.g., LayoutInfo) immediately after calling this function, even if they have not called Present or SetRootTransform. This allows clients to wait for layout information from their parent before calling Present.

Any illegal operations on ParentViewportWatcher will cause both ParentViewportWatcher channel and this Flatland channel to be torn down.

Lifecycle note. The lifetime of the ParentViewportWatcher channel is bound by the peer ViewportCreationToken. When the ViewportCreationToken dies, this ParentViewportWatcher channel is destroyed.

Request

NameType
token fuchsia.ui.views/ViewCreationToken
parent_viewport_watcher request<ParentViewportWatcher>

CreateView2

Identical to CreateView, except it allows association of View identity (ViewRef) and view-bound protocols.

Request

NameType
token fuchsia.ui.views/ViewCreationToken
view_identity fuchsia.ui.views/ViewIdentityOnCreation
protocols ViewBoundProtocols
parent_viewport_watcher request<ParentViewportWatcher>

CreateViewport

The Viewport and View pair, together, represent the connection between two Flatland instances. The Viewport is created in the parent, and the View is created in the child. The parent has control over how the child's View is integrated into its own View.

Any illegal operations on ChildViewWatcher will cause both ChildViewWatcher channel and this Flatland channel to be torn down.

ViewportProperties must have logical_size set. This is the initial size that will drive the layout of the child. The logical_size is also used as the default Content size, but subsequent changes to the logical_size will have no effect on the Content size.

The logical_size must have positive X and Y components.

Zero is not a valid ContentId. All other values are valid, assuming they are not already in use for another piece of Content (see ReleaseViewport for more details).

Lifecycle note. The lifetime of the ChildViewWatcher channel is bound by the peer ViewCreationToken. When the ViewCreationToken dies, this ChildViewWatcher channel is destroyed.

Request

NameType
viewport_id ContentId
token fuchsia.ui.views/ViewportCreationToken
properties ViewportProperties
child_view_watcher request<ChildViewWatcher>

OnError

If an error occurrs after a Present, an OnError event will fire with associated information.

FlatlandErrors will close the connection with the client.

  • response error the error a client may receive after performing some invalid operations.

Response

NameType
error FlatlandError

OnFramePresented

This event is fired whenever a set of one or more Presents are presented simultaneously, and are therefore no longer in flight.

This event signifies that the commands enqueued before the Present have taken effect in the scene graph, and are globally visible.

Clients do NOT have to implement a handler for this event for basic frame scheduling, unless they explicitly want feedback on prior frame presentation. All future frame information is given in the OnNextFrameBegin event.

TODO(fxbug.dev/63305): remove num_presents_allowed from this event.

Response

NameType
frame_presented_info fuchsia.scenic.scheduling/FramePresentedInfo

OnNextFrameBegin

This event is fired when clients should expect minimal resource contention. Clients may use the timing of this event to begin their rendering work, using the information returned to inform their scheduling decisions.

Importantly, OnNextFrameBegin is only fired when the client has one or more present credits, including what is returned in this event. It is therefore safe to present once every time this event fires.

  • response values the table of information a client needs to produce its next frame. See OnNextFrameBeginValues for more information.

Response

NameType
values OnNextFrameBeginValues

Present

Complete execution of all feed-forward operations.

If executing an operation produces an error (e.g., CreateTransform(0)), an OnError event is emitted. Operations that produce errors are ignored and the channel is closed.

If the execution is completed successfully, OnNextFrameBegin emits NO_ERROR along with other valid fields.

The client may only call Present when they have a non-zero number of present credits, which are tracked by the server. The server may increment the number of credits when it fires the OnNextFrameBegin event, which informs the client when it receives additional present credits. Each Present call uses one present credit and decrements the server count by one. If the client calls Present with no present credits, the server will return a NO_PRESENTS_REMAINING error.

The client should assume that prior to receiving any OnNextFrameBegin events, they have one present credit.

Every Present call results in one OnNextFrameBegin event, and one OnFramePresented event, typically in that order.

When the commands flushed by Present make it to display, an OnFramePresented event is fired. This event includes information pertaining to all Presents that had content that were part of that frame.

See fuchsia.ui.composition/PresentArgs documentation above for more detailed information on what arguments are passed in and their role.

Request

NameType
args PresentArgs

ReleaseFilledRect

Automatically garbage collects the rectangle when it is no longer needed for rendering. |rect_id| must have been instantiated with a call to |CreateFilledRect|. Once released, the ID immediately goes out of scope and is free to be used again.

Request

NameType
rect_id ContentId

ReleaseImage

Released Images will be garbage collected by the system once they are no longer necessary for rendering. For Images, this means the Image is no longer attached to any Transform and any pending rendering that references the Image is complete.

Use SetContent(transform_id, 0) to clean up references to released Images.

Once released, the id immediately goes out of scope for future function calls and can be reused when creating new Images.

It is an error to call functions with a released id (unless that id has been reused to construct a new Image).

Request

NameType
image_id ContentId

ReleaseTransform

Released Transforms will be garbage collected by the system once they are no longer necessary for rendering. For Transforms, this means there is no path from any unreleased Transform to the newly-released Transform.

Once released, the id immediately goes out of scope for future function calls and can be reused when creating new Transforms.

It is an error to call functions with a released id (unless that id has been reused to construct a new Transform).

Request

NameType
transform_id TransformId

ReleaseView

Request

<EMPTY>

ReleaseViewport

Releases a Viewport from the scene, even if the Viewport is still connected to a Transform. Unlike other resources, Viewports are garbage collected by the system during the next Present because a removed Viewport is guaranteed to provide no renderable content.

Use SetContent(transform_id, 0) to clean up references to released Viewports.

Despite having a return type, this function is still feed-forward like CreateView and requires a call to Present to be executed. The ViewportCreationToken will be returned after the presented operations have been executed.

Request

NameType
viewport_id ContentId

Response

NameType
token fuchsia.ui.views/ViewportCreationToken

RemoveChild

Removes a child Transform from a parent Transform.

Request

NameType
parent_transform_id TransformId
child_transform_id TransformId

SetClipBounds

This sets the bounds in pixel space that the renderables can be rendered in. If the area of a renderable exceeds the clip bounds, the area outside the bounds will not be rendered. These bounds are valid for all children of this transform node as well. The default state is for a transform to be unclipped, meaning it will not have any bounds placed on its render region. The clip width/height must be positive. The only exception is that setting the clip rect to {-1, -1, -1, -1} will remove the clip bounds altogether.

Request

NameType
transform_id TransformId
rect fuchsia.math/Rect

SetContent

Setting a piece of Content on a Transform makes that Content visible in the render tree as long as the Transform is visible from the root Transform. The Content will be rendered before, and therefore "behind", any Content attached to the descendants of the Transform.

Because each Transform can have, at most, a single piece of Content on it, calling this function on a Transform that already has Content will replace that Content.

A Content may be set on more than one Transform.

Calling this function with a Content id of 0 will remove any Content currently on the Transform.

Request

NameType
transform_id TransformId
content_id ContentId

SetDebugName

Set debug name of the current client that can be used by Flatland to print as a prefix to logs to help client distinguish what is theirs. name can be an arbitrary string, but the current process name (see fsl::GetCurrentProcessName()) is a good default.

Request

NameType
name string[64]

SetHitRegions

Sets the interactive areas for a Transform. By default, Content is not interactive; hit regions must be placed for a user to interact with the Content in a View. Because hit regions are described in the Flatland protocol, a Flatland instance can synchronize Content and hit regions.

Each hit region is placed in the coordinate space of the owning Transform, and may or may not interact with different types of hit testing, depending on its HitTestInteraction type. When there are multiple hit regions that intersect with a hit test, the precedence rules given below dictate which hit region has interacted with the hit test. Only Transforms that transitively connect to the root Transform have their hit regions interact with a hit test.

Precedence rules Within a Transform, if multiple hit regions overlap, the hit test examines each intersecting hit region for a possible interaction. Thus, for a regular hit test H and an accessibility hit test A, where R and A both intersect two hit regions D (DEFAULT) and S (SEMANTICALLY_INVISIBLE) on the same Transform, (1) R interacts with both D and S, and (2) A only interacts with D. Generally, hit regions that overlap in a single Transform can cause confusing behavior.

Within a View, for a given hit test, the front-most Transform's hit regions take precedence over those behind. This follows the expected reverse "render order" of Transforms (described in CreateTransform), where a user expects to interact with Content that is visible, or front-most.

Across Flatland instances, for a given hit test, the front-most instance's front-most Transform's hit regions take precedence over those behind. This follows the expected reverse "render order" of views, where a user expects to interact with the View that is visible, or front-most. For example, if a child View owns Content that is rendered over the parent View, the user expects to interact with the child's Content.

To reset a Transform to "no hit testing": send an empty vector.

Request

NameType
transform_id TransformId
regions vector<HitRegion>[64]

SetImageDestinationSize

The content size for an Image is the size of the rectangle in the parent's space that the image occupies. This combined with the global translation of the transform it is attached to determines the size and location of where the content is rendered on the display.

Request

NameType
image_id ContentId
size fuchsia.math/SizeU

SetImageOpacity

Sets an opacity in linear space to be applied to a flatland image. Opacity values must be in the range [0.0, 1.0].

Request

NameType
image_id ContentId
val float32

SetImageSampleRegion

This function is used to determine the region (in texel space) of an image that will be used by Flatland when rendering. The image to be sampled is referenced by image_id and the sample region is specified by rect which itself is comprised of an origin point (x,y) as well as a width and height, in unnormalized coordinates. It is illegal to call this function on non-image content, or to sample a region outside of the texel space of the image. In other words, the region specifed by rect must not exceed the ranges (0, image_width) and (0, image_height). If (rect.x + rect.width > image_width) or (rect.y + rect.height > image_height) or if any of the values are negative, this will result in an error.

Request

NameType
image_id ContentId
rect fuchsia.math/RectF

SetOrientation

Sets the orientation on a Transform. The order of geometric attribute application is addressed in the documentation for SetTranslation.

Request

NameType
transform_id TransformId
orientation Orientation

SetRootTransform

Sets the Root Transform for the graph.

The sub-graph defined by the Root Transform and its children will be rendered as View in the connected parent's Viewport (see CreateView). Any parents of the Root Transform in this Graph will be ignored.

The Root Transform, and all children of the Root Transform, are kept alive if they are released (see ReleaseTransform for more details).

There is only ever one Root. Since 0 is not a valid transform id (see CreateTransform), calling SetRootTransform(0) clears the current Root, destroying any previously released objects that are not referenced by the new root.

Request

NameType
transform_id TransformId

SetSolidFill

Defines the color and size of a filled rect. |rect_id| must refer to content that was created via a call to CreateFilledRect. The color is not premultiplied.

Request

NameType
rect_id ContentId
color ColorRgba
size fuchsia.math/SizeU

SetTranslation

All Transform objects support all attributes.

Geometric attributes are applied in the following order:

  1. Translation (relative to the parent's coordinate space)
  2. Orientation (around the new origin as defined by the translation)
  3. Clipping (performed in pixel space to constrain the transform's render region)

Sets the translation on a Transform. The order of geometric attribute application is addressed above.

Request

NameType
transform_id TransformId
translation fuchsia.math/Vec

SetViewportProperties

Transforms are usually sufficient to change how Content is presented. Viewports, however, have special properties that are not part of the Transform hierarchy. Those properties can be set using this function.

The logical_size must have positive X and Y components.

Request

NameType
viewport_id ContentId
properties ViewportProperties

FlatlandDisplay

Defined in fuchsia.ui.composition/flatland.fidl

This API connects to the singleton "primary display", and allows a tree of Flatland content to be attached underneath. Only one FlatlandDisplay client connection is allowed at one time.

SetContent

Request

NameType
token fuchsia.ui.views/ViewportCreationToken
child_view_watcher request<ChildViewWatcher>

ParentViewportWatcher

Defined in fuchsia.ui.composition/flatland.fidl

A protocol that provides information about the parent Viewport attached to a Flatland instance's sole View. Although Flatland instances can have at most one view, it is possible to have multiple ParentViewportWatchers during the brief transition period when replacing the instance's View with another, e.g. via CreateView. During this period, certain updates may be duplicated and sent to each ParentViewportWatcher connection.

A ParentViewportWatcher will remain connected as long as the corresponding parent Viewport exists; the connection will also be closed if the parents's ViewportCreationToken is dropped without using it to create a Viewport.

GetLayout

A hanging get for receiving layout information. Clients may receive layout information before the ParentViewportWatcher operation has been presented. This allows children to layout their content before their first call to Present. In transition cases where two ParentViewportWatcher channels exist at the same time, both protocol instances will be receiving different layout information.

This hanging get will only fire when the LayoutInfo is different than the previously returned LayoutInfo. Note that, since LayoutInfo is a table, only some fields may have changed.

It is invalid to call GetLayout while a previous call is still pending. Doing so will cause both this channel and the Flatland channel that handed out ParentViewportWatcher to be closed.

Request

<EMPTY>

Response

NameType
info LayoutInfo

GetStatus

A hanging get for receiving the status of the parent Viewport. This provides global connectivity information to the child.

This hanging get will only fire when the ParentViewportStatus is different than the previously returned ParentViewportStatus.

It is invalid to call GetStatus while a previous call is still pending. Doing so will cause both this channel and the Flatland channel that handed out ParentViewportWatcher to be closed.

Request

<EMPTY>

Response

NameType
status ParentViewportStatus

Screenshot

Defined in fuchsia.ui.composition/screenshot.fidl

This protocol provides a low-level Screenshot API for clients to use. Screenshot clients should familiarize themselves with the fuchsia.sysmem/BufferCollection and fuchsia.ui.composition/Allocator protocols as those are necessary to create the BufferCollections and images Screenshot uses.

CreateImage

Clients should first use the Allocator protocol to register a BufferCollection for screenshot use.

Afterwards, clients should create the image that will eventually be rendered to using this method.

Finally, clients can use their specified ImageId in TakeScreenshot().

Request

NameType
args CreateImageArgs

Response

NameType
result Screenshot_CreateImage_Result

RemoveImage

Following a successful call to CreateImage, clients can call RemoveImage to delete the image and its associated metadata.

Request

NameType
args RemoveImageArgs

Response

NameType
result Screenshot_RemoveImage_Result

TakeScreenshot

Following a successful call to CreateImage, clients can call TakeScreenshot giving that same image ID. Clients are responsible for determining the rotation of the display, and applying the corrective rotation.

For instance, if the display is mounted 90 degrees clockwise (the "top" is on the right, when looking at the display), then the client should specify a 270 degree rotation to account for it. Similarly, the clients are responsible for specifying a buffer big enough for the rotated image. If the buffer is too small, a best effort attempt will be made to render the image.

Clients should wait on the zx::event they pass for successful completion of the screenshot. It is not guaranteed that the screenshot will be completed by the time this function returns.

Request

NameType
args TakeScreenshotArgs

Response

NameType
result Screenshot_TakeScreenshot_Result

STRUCTS

Allocator_RegisterBufferCollection_Response

Defined in fuchsia.ui.composition/allocator.fidl

<EMPTY>

BufferCollectionExportToken resource

Defined in fuchsia.ui.composition/allocator.fidl

A typed wrapper for an eventpair, representing the registry endpoint of a buffer collection.

FieldTypeDescriptionDefault
value handle<eventpair> No default

BufferCollectionImportToken resource

Defined in fuchsia.ui.composition/allocator.fidl

A typed wrapper for an eventpair, representing the Image import endpoint of a buffer collection.

FieldTypeDescriptionDefault
value handle<eventpair> No default

ColorRgba

Defined in fuchsia.ui.composition/flatland.fidl

FieldTypeDescriptionDefault
red float32 No default
green float32 No default
blue float32 No default
alpha float32 No default

ContentId

Defined in fuchsia.ui.composition/flatland.fidl

A user-defined identifier for a particular piece of Content. See Content creation functions (e.g. CreateViewport, CreateImage) for more information.

FieldTypeDescriptionDefault
value uint64 No default

HitRegion

Defined in fuchsia.ui.composition/flatland.fidl

An interactive area of a View, placed in the coordinate space of a specific Transform.

FieldTypeDescriptionDefault
region fuchsia.math/RectF

The position and size of this hit region, in the coordinate space of the Transform that owns this hit region.

No default
hit_test HitTestInteraction

The interaction behavior specified for this hit region. To specify "no interaction at all", remove this hit region from the owning Transform.

No default

Screenshot_CreateImage_Response

Defined in fuchsia.ui.composition/screenshot.fidl

<EMPTY>

Screenshot_RemoveImage_Response

Defined in fuchsia.ui.composition/screenshot.fidl

<EMPTY>

Screenshot_TakeScreenshot_Response

Defined in fuchsia.ui.composition/screenshot.fidl

<EMPTY>

TransformId

Defined in fuchsia.ui.composition/flatland.fidl

A user-defined identifier for a particular transform. See CreateTransform and ReleaseTransform for more information.

FieldTypeDescriptionDefault
value uint64 No default

ENUMS

ChildViewStatus strict

Type: uint32

Defined in fuchsia.ui.composition/flatland.fidl

NameValueDescription
CONTENT_HAS_PRESENTED 1

The underlying Flatland instance has connected its View, called Present, and the acquisition fences of the Present call have all be reached, indicating that it has some content ready to be displayed, and NOT that the child content has actually been shown on the screen (a common use case is for the parent to wait for the child content to be ready before attaching the child to the global scene graph).

FlatlandError strict

Type: uint32

Defined in fuchsia.ui.composition/flatland.fidl

The set of error codes returned in OnError. Everything except NO_ERROR, causes Flatland channel to be closed.

NameValueDescription
BAD_OPERATION 1

Indicates that the parameters used the function calls are invalid.

NO_PRESENTS_REMAINING 2

Indicates that additional_present_credits field was not properly processed and the client queued more Presents than allowed.

BAD_HANGING_GET 3

Indicates that the client has overwritten hanging gets in the protocols returned.

HitTestInteraction flexible

Type: uint8

Defined in fuchsia.ui.composition/flatland.fidl

The kind of hit test interaction expected for a hit region.

NameValueDescription
DEFAULT 0

The natural default behavior is for a hit region to interact with both regular hit testing and accessibility hit testing.

SEMANTICALLY_INVISIBLE 1

Some use cases require that a hit region to interact with regular hit testing, but not interact with accessibility hit testing. Here, "semantics" refers to accessibility's semantic tree data, which describes UI elements in a View.

Orientation strict

Type: uint32

Defined in fuchsia.ui.composition/flatland.fidl

NameValueDescription
CCW_0_DEGREES 1
CCW_90_DEGREES 2
CCW_180_DEGREES 3
CCW_270_DEGREES 4

ParentViewportStatus strict

Type: uint32

Defined in fuchsia.ui.composition/flatland.fidl

ParentViewportWatchers will be informed when they are actively attached to a output display (either directly, or through a chain of parent Viewports) and when they are not. Until they are connected to a display, some pieces of information (such as pixel scale) may be unavailable.

NameValueDescription
CONNECTED_TO_DISPLAY 1
DISCONNECTED_FROM_DISPLAY 2

RegisterBufferCollectionError strict

Type: uint32

Defined in fuchsia.ui.composition/allocator.fidl

The set of error codes returned by Allocator::RegisterBufferCollection().

NameValueDescription
BAD_OPERATION 1

RegisterBufferCollectionUsage strict

Type: uint32

Defined in fuchsia.ui.composition/allocator.fidl

The possible usages for registered buffer collection.

NameValueDescription
DEFAULT 0

DEFAULT means that the specified buffer collection will be used for Flatland and gfx image creation.

See fuchsia.ui.composition/Flatland.CreateImage for more.

SCREENSHOT 1

SCREENSHOT means that the specified buffer collection will be used for screenshotting purposes.

Rotation strict

Type: uint32

Defined in fuchsia.ui.composition/screenshot.fidl

The rotation to be applied to the image.

If a given display is rotated, say, 270 degrees according to its display_info config file, then applying the equal and opposite rotation, CW_270_DEGREES, should cancel the display rotation leading to a correctly rendered screenshot.

Clients should allocate an image according to the final dimensions they ultimately want to use, i.e. after rotation. These would be identical to the width and height values found in the display_info config file.

NameValueDescription
CW_0_DEGREES 0
CW_90_DEGREES 1
CW_180_DEGREES 2
CW_270_DEGREES 3

ScreenshotError strict

Type: uint32

Defined in fuchsia.ui.composition/screenshot.fidl

The enum of possible errors following a CreateImage or TakeScreenshot call.

NameValueDescription
MISSING_ARGS 1

One or more arguments are missing in the table argument.

BAD_OPERATION 2

A general error occurred during the method call.

TABLES

CreateImageArgs resource

Defined in fuchsia.ui.composition/screenshot.fidl

The table of arguments passed into the CreateImage call. Note that all fields are necessary.

OrdinalFieldTypeDescription
1 image_id ImageId

The image ID for the image about to be created. It must be unique, and may not be 0, which is invalid.

2 import_token BufferCollectionImportToken

The import token referencing a BufferCollection registered with Allocator. This function will fail unless all clients of the specified BufferCollection have set their constraints.

3 vmo_index uint32

The VMO index must be valid and in the range of constraints of the specified BufferCollection.

4 size fuchsia.math/SizeU

The size of the image in pixels.

ImageProperties

Defined in fuchsia.ui.composition/flatland.fidl

The properties of an Image as defined by the client. These properties determine how an Image uses the backing BufferCollection. See CreateImage for more information.

OrdinalFieldTypeDescription
1 size fuchsia.math/SizeU

The size of the Image in pixels.

LayoutInfo

Defined in fuchsia.ui.composition/flatland.fidl

The return type of GetLayout. This table contains most of the information necessary for a client to decide how to layout their content in a Flatland instance. This data may be provided to the client before the command that creates the View is presented, so that the client may lay out content properly before their first call to Present.

OrdinalFieldTypeDescription
1 logical_size fuchsia.math/SizeU

The layout size of a View in logical pixels, defined by the parent's call to SetViewportProperties. Clients should re-layout their content when this value changes.

2 pixel_scale fuchsia.math/SizeU

The ratio from physical display pixels to logical pixels, defined by the sizes and scale transforms of the parent: each logical pixel is displayed on-screen by one or more physical pixels, as determined by this scale. Clients should not necessarily re-layout their content when this value changes.

OnNextFrameBeginValues

Defined in fuchsia.ui.composition/flatland.fidl

Fields that a client needs in order to produce its next frame, returned in OnNextFrameBegin. Each field is guaranteed to be set and contain valid information.

OrdinalFieldTypeDescription
1 additional_present_credits uint32

The number of additional Present calls allowed to the client so that they can call Present further times. This is a delta in the present credit budget, not the absolute number of present credits.

2 future_presentation_infos FuturePresentationInfos

Information about future presentation and latch times that a client may aim for precise scheduling behavior.

PresentArgs resource

Defined in fuchsia.ui.composition/flatland.fidl

Arguments passed into Present. All arguments are optional, and if an argument is omitted Flatland will use a reasonable default, specified below.

OrdinalFieldTypeDescription
1 requested_presentation_time zx/time

requested_presentation_time specifies the time on or after which the client would like the enqueued operations to take visible effect (light up pixels on the screen), expressed in nanoseconds in the CLOCK_MONOTONIC timebase.

The default requested_presentation_time is 0.

Using a requested_presentation_time in the present or past (such as 0) schedules enqueued operations to take visible effect as soon as possible, during the next frame to be prepared.

Using a requested_presentation_time in the future schedules the enqueued operations to take visible effect on or as closely as possible after the stated time, but no earlier.

Each rendered frame has a target presentation time. This is when Flatland aims to have the frame presented to the user. Before rendering a frame, Flatland applies all enqueued operations associated with all squashable calls to Present whose requested_presentation_time is on or before the frame's target presentation time.

2 acquire_fences vector<event>[16]

Flatland will wait until all of a Flatland instance's acquire_fences are ready before it will execute the presented commands. Not signaling acquire_fences will block the current Present as well as the following ones even if their acquire_fences are signaled.

The default acquire_fences value is the empty vector.

3 release_fences vector<event>[16]

Flatland will signal all release_fences when the resources and shared buffers from this Present are no longer in use. Callers should not modify shared resources, such as BufferCollections, until after these fences are signaled.

If an error occurs, release fences are not necessarily fired as Flatland can close the client's instance at any point.

The default release_fences value is the empty vector.

4 unsquashable bool

If unsquashable is true, then the update is guaranteed to be uniquely shown for at least one vsync interval.

If unsquashable is false, then the update can be combined with those that come after it.

If absent, unsquashable is false.

5 server_wait_fences vector<event>[16]

Flatland will wait until all of a Flatland instance's server_wait_fences are ready before it will execute the presented commands. Not signaling server_wait_fences will block the current Present as well as the following ones even if their server_wait_fences are signaled.

The default server_wait_fences value is the empty vector.

6 server_signal_fences vector<event>[16]

(read this one carefully, it may be counter-intuitive)

Flatland will signal all server_signal_fences when the resources and shared buffers from the previous Present are no longer in use. Callers should not modify shared resources, such as BufferCollections, until after these fences are signaled. Otherwise, there may be graphical artifacts such as tearing, caused by the client modifying content which is still visible on screen.

The following example explains why the fences correspond to the previous frame's resources, not the current frame. Consider an app which uses a separate image for a pop-up dialog, which will disappear immediately if the user taps elsewhere. The app cannot tell whether the image will be removed next frame because, if this happens, it will be due to user input which has not yet occurred. Since the image will probably continue to be presented next frame, it wouldn't make sense to provide a fence this frame.

If an error occurs, Flatland may close the channel without signaling these fences. Clients may immediately release shared buffers, but they should not immediately modify such buffers, because they may still be displayed on screen. There is currently no good signal available to the client about when it is safe to reuse shared buffers.

The default server_signal_fences value is the empty vector.

RegisterBufferCollectionArgs resource

Defined in fuchsia.ui.composition/allocator.fidl

The table of arguments for RegisterBufferCollection. Note that some fields below are REQUIRED.

OrdinalFieldTypeDescription
1 export_token BufferCollectionExportToken

Clients can send export_token to register buffer collections with Allocator to be used later in fuchsia.ui.composition/Flatland instances or other Scenic APIs, such as Screenshot.

For example, by passing a BufferCollectionImportToken containing the matching peer of BufferCollectionExportToken, they can create image resources via fuchsia.ui.composition/Flatland.CreateImage.

Clients should wait for the response before using import_token.

This field is REQUIRED.

2 buffer_collection_token fuchsia.sysmem/BufferCollectionToken

Flatland participates in the allocation of buffers by setting constraints on the BufferCollection referenced by buffer_collection_token. It will not block on buffers being allocated until the client creates content using the BufferCollection.

The buffer collection registered with export_token is available and kept alive as long as the client holds a valid BufferCollectionImportToken. They will be garbage collected when all BufferCollectionImportTokens are closed and all the associated Image resources are released.

This field is REQUIRED.

3 usage RegisterBufferCollectionUsage

The client can register a buffer collection for various uses, each coming with their own unique constraints.

This field is OPTIONAL. If usage is omitted it will be treated as if it has the DEFAULT option.

RemoveImageArgs resource

Defined in fuchsia.ui.composition/screenshot.fidl

OrdinalFieldTypeDescription
1 image_id ImageId

The image ID for the image to be removed.

TakeScreenshotArgs resource

Defined in fuchsia.ui.composition/screenshot.fidl

OrdinalFieldTypeDescription
1 image_id ImageId

The ID of the image previously allocated with CreateImage.

2 rotation Rotation

The rotation to be applied to the image. Not necessary; default value is no rotation.

3 event handle<event>

The event to fire upon successful completion.

ViewBoundProtocols resource

Defined in fuchsia.ui.composition/flatland.fidl

The protocol endpoints bound to a Flatland ViewCreationToken. These protocols operate on the View that ViewCreationToken created in the Flatland session.

OrdinalFieldTypeDescription
1 view_ref_focused request<fuchsia.ui.views/ViewRefFocused>

Learn when a View gains focus.

Server-bound ViewRef. The view_ref_focused client does not specify the ViewRef explicitly; instead, the server implementation uses the ViewRef used in View creation for reporting focus movement on/off this View.

2 view_focuser request<fuchsia.ui.views/Focuser>

Enable a View to request focus transfer to a child (target) View.

Server-bound ViewRef. The view_focuser client does not specify the "requestor" ViewRef explicitly, only the "target" ViewRef. Instead, the server implementation uses the ViewRef used in View creation as the "requestor" ViewRef.

3 touch_source request<fuchsia.ui.pointer/TouchSource>

Receive touch events that are associated with a View.

4 mouse_source request<fuchsia.ui.pointer/MouseSource>

Receive mouse events that are associated with a View.

ViewportProperties

Defined in fuchsia.ui.composition/flatland.fidl

The properties of a Viewport as defined by the parent. This data, along with the set of attached Transforms, will be used to compute the LayoutInfo for the View of the Viewport.

OrdinalFieldTypeDescription
1 logical_size fuchsia.math/SizeU

The size of the Viewport in logical pixels. This maps directly to the logical_size field in LayoutInfo.

UNIONS

Allocator_RegisterBufferCollection_Result strict

Defined in fuchsia.ui.composition/allocator.fidl

Ordinal
VariantTypeDescription
1 response Allocator_RegisterBufferCollection_Response
2 err RegisterBufferCollectionError

Screenshot_CreateImage_Result strict

Defined in fuchsia.ui.composition/screenshot.fidl

Ordinal
VariantTypeDescription
1 response Screenshot_CreateImage_Response
2 err ScreenshotError

Screenshot_RemoveImage_Result strict

Defined in fuchsia.ui.composition/screenshot.fidl

Ordinal
VariantTypeDescription
1 response Screenshot_RemoveImage_Response
2 err ScreenshotError

Screenshot_TakeScreenshot_Result strict

Defined in fuchsia.ui.composition/screenshot.fidl

Ordinal
VariantTypeDescription
1 response Screenshot_TakeScreenshot_Response
2 err ScreenshotError

CONSTANTS

NameValueTypeDescription
MAX_ACQUIRE_RELEASE_FENCE_COUNT 16 int32
MAX_HIT_REGION_COUNT 64 int32

A maximum of 64 hit regions is enough for the expected usage of these APIs.

MAX_PRESENT_ARGS_FENCE_COUNT 16 int32

TYPE ALIASES

NameValueDescription
FuturePresentationInfos vector[8]

A user-defined identifier for future presentation info. A maximum of 8 future presentation counts is enough for the current usage of these APIs.

ImageId uint64