ComplicationSlot

fun createBackgroundComplicationSlotBuilder(
    id: Int,
    canvasComplicationFactory: CanvasComplicationFactory,
    supportedTypes: List<ComplicationType>,
    defaultDataSourcePolicy: DefaultComplicationDataSourcePolicy
): ComplicationSlot.Builder

Constructs a Builder for a complication with bound type ComplicationSlotBoundsType.BACKGROUND whose bounds cover the entire screen. A background complication is for watch faces that wish to have a full screen user selectable backdrop. This sort of complication isn't clickable and at most one may be present in the list of complicationSlots.

fun createEdgeComplicationSlotBuilder(
    id: Int,
    canvasComplicationFactory: CanvasComplicationFactory,
    supportedTypes: List<ComplicationType>,
    defaultDataSourcePolicy: DefaultComplicationDataSourcePolicy,
    bounds: ComplicationSlotBounds,
    complicationTapFilter: ComplicationTapFilter
): ComplicationSlot.Builder

Constructs a Builder for a complication with bounds type ComplicationSlotBoundsType.EDGE.

An edge complication is drawn around the border of the display and has custom hit test logic (see complicationTapFilter). When tapped the associated intent is dispatched. Edge complicationSlots should have a custom renderer with CanvasComplication.drawHighlight overridden.

Note hit detection in an editor for ComplicationSlots created with this method is not supported.

@ComplicationExperimental
fun createEdgeComplicationSlotBuilder(
    id: Int,
    canvasComplicationFactory: CanvasComplicationFactory,
    supportedTypes: List<ComplicationType>,
    defaultDataSourcePolicy: DefaultComplicationDataSourcePolicy,
    bounds: ComplicationSlotBounds,
    boundingArc: BoundingArc,
    complicationTapFilter: ComplicationTapFilter = object : ComplicationTapFilter {
                    override fun hitTest(
                        complicationSlot: ComplicationSlot,
                        screenBounds: Rect,
                        x: Int,
                        y: Int,
                        @Suppress("UNUSED_PARAMETER") includeMargins: Boolean
                    ) =
                        boundingArc.hitTest(
                            complicationSlot.computeBounds(screenBounds),
                            x.toFloat(),
                            y.toFloat()
                        )
                }
): ComplicationSlot.Builder

Constructs a Builder for a complication with bounds type ComplicationSlotBoundsType.EDGE, whose contents are contained within boundingArc.

fun createRoundRectComplicationSlotBuilder(
    id: Int,
    canvasComplicationFactory: CanvasComplicationFactory,
    supportedTypes: List<ComplicationType>,
    defaultDataSourcePolicy: DefaultComplicationDataSourcePolicy,
    bounds: ComplicationSlotBounds
): ComplicationSlot.Builder

Constructs a Builder for a complication with bounds type ComplicationSlotBoundsType.ROUND_RECT. This is the most common type of complication. These can be tapped by the user to trigger the associated intent.

fun computeBounds(screen: Rect, applyMargins: Boolean = false): Rect

Computes the bounds of the complication by converting the unitSquareBounds of the current complication type to pixels based on the screen's dimensions.

fun isActiveAt(instant: Instant): Boolean

Whether or not the complication should be considered active and should be rendered at the specified time.

@UiThread
fun render(
    canvas: Canvas,
    zonedDateTime: ZonedDateTime,
    renderParameters: RenderParameters
): Unit

Watch faces should use this method to render a complication. Note the system may call this.

@UiThread
fun renderHighlightLayer(
    canvas: Canvas,
    zonedDateTime: ZonedDateTime,
    renderParameters: RenderParameters
): Unit

Watch faces should use this method to render non-fixed complicationSlots for any highlight layer pass. Note the system may call this.

val accessibilityTraversalIndex: Int

This is used to determine the order in which accessibility labels for the watch face are read to the user. Accessibility labels are automatically generated for the time and complicationSlots. See also Renderer.additionalContentDescriptionLabels.

val boundsType: Int

The ComplicationSlotBoundsTypeIntDef of the complication slot.

val canvasComplicationFactory: CanvasComplicationFactory

The CanvasComplicationFactory used to generate a CanvasComplication for rendering the complication. The factory allows us to decouple ComplicationSlot from potentially expensive asset loading.

val complicationData: StateFlow<ComplicationData>

The androidx.wear.watchface.complications.data.ComplicationData associated with the ComplicationSlot. This defaults to NoDataComplicationData.

val complicationSlotBounds: ComplicationSlotBounds

The complication's ComplicationSlotBounds which are converted to pixels during rendering.

Note it's not allowed to change the bounds of a background complication because they are assumed to always cover the entire screen.

var configExtras: Bundle

Extras to be merged into the Intent sent when invoking the complication data source chooser activity.

val defaultDataSourcePolicy: DefaultComplicationDataSourcePolicy

The DefaultComplicationDataSourcePolicy which defines the default complicationSlots providers selected when the user hasn't yet made a choice. See also defaultDataSourceType.

val defaultDataSourceType: ComplicationType

The default ComplicationType to use alongside defaultDataSourcePolicy.

val enabled: Boolean

Whether or not the complication should be drawn and accept taps.

val fixedComplicationDataSource: Boolean

Whether or not the complication data source is fixed (i.e. can't be changed by the user). This is useful for watch faces built around specific complications.

val id: Int

The Watch Face's ID for the complication slot.

val initiallyEnabled: Boolean

At creation a complication slot is either enabled or disabled. This can be overridden by a ComplicationSlotsUserStyleSetting (see ComplicationSlotOverlay.enabled). Editors need to know the initial state of a complication slot to predict the effects of making a style change.

val nameResourceId: Int?

The optional ID of string resource (or null if absent) to identify the complication slot on screen in an editor. These strings should be short (perhaps 10 characters max) E.g. complication slots named 'left' and 'right' might be shown by the editor in a list from which the user selects a complication slot for editing.

val renderer: CanvasComplication

The CanvasComplication used to render the complication. This can't be used until after WatchFaceService.createWatchFace has completed.

val screenReaderNameResourceId: Int?

The optional ID of a string resource (or null if absent) for use by a watch face editor to identify the complication slot in a screen reader. While similar to nameResourceId this string can be longer and should be more descriptive. E.g. saying 'left complication' rather than just 'left'.

val tapFilter: ComplicationTapFilter

The ComplicationTapFilter used to determine whether or not a tap hit the complication slot.