InteractiveWatchFaceClient

default static final int TAP_TYPE_CANCEL

Indicates that a previous TAP_TYPE_DOWN event has been canceled. This generally happens when the watch face is touched but then a move or long press occurs.

default static final int TAP_TYPE_DOWN

Indicates a "down" touch event on the watch face.

default static final int TAP_TYPE_UP

Indicates that an "up" event on the watch face has occurred that has not been consumed by another activity. A TAP_TYPE_DOWN always occur first. This event will not occur if a TAP_TYPE_CANCEL is sent.

@AnyThread
abstract void addClientDisconnectListener(
    @NonNull InteractiveWatchFaceClient.ClientDisconnectListener listener,
    @NonNull Executor executor
)

Registers a ClientDisconnectListener.

@WatchFaceClientExperimental
default void addOnWatchFaceColorsListener(
    @NonNull Executor executor,
    @NonNull Consumer<WatchFaceColors> listener
)

Registers a Consumer which gets called initially with the current Renderer.watchfaceColors if known or null if not, and subsequently whenever the watch face's Renderer.watchfaceColors change.

abstract void addOnWatchFaceReadyListener(
    @NonNull Executor executor,
    @NonNull InteractiveWatchFaceClient.OnWatchFaceReadyListener listener
)

Registers a OnWatchFaceReadyListener which gets called when the watch face is ready to render.

Note in the event of the watch face disconnecting (e.g. due to a crash) the listener will never get called. Use ClientDisconnectListener to observe disconnects.

@RequiresApi(value = 30)
default RemoteWatchFaceViewHost createRemoteWatchFaceViewHost(
    @NonNull IBinder hostToken,
    @Px int width,
    @Px int height
)

Constructs a RemoteWatchFaceViewHost whose RemoteWatchFaceViewHost.surfacePackage can be attached to a SurfaceView owned by the client with SurfaceView.setChildSurfacePackage. The watch face will render into this view upon demand (see RemoteWatchFaceViewHost.renderWatchFace).

This is more efficient than calling renderWatchFaceToBitmap multiple times, although there is some overhead (memory and cpu) to setting up a RemoteWatchFaceViewHost.

Requires the watchface to be compiled with a compatible library, to check if that's the case use isRemoteWatchFaceViewHostSupported.

default Integer getComplicationIdAt(@Px int x, @Px int y)

Returns the ID of the androidx.wear.watchface.ComplicationSlot at the given coordinates or null if there isn't one.

Note this currently doesn't support Edge complications.

abstract @NonNull Map<@NonNull Integer, @NonNull ComplicationSlotState> getComplicationSlotsState()

Map of androidx.wear.watchface.ComplicationSlot ids to ComplicationSlotState for each ComplicationSlot registered with the watch face's ComplicationSlotsManager. The ComplicationSlotState is based on the initial state of each androidx.wear.watchface.ComplicationSlot plus any overrides from a ComplicationSlotsUserStyleSetting. As a consequence ComplicationSlotState may update based on style changes.

abstract @NonNull List<@NonNull ContentDescriptionLabel> getContentDescriptionLabels()

Returns the ContentDescriptionLabels describing the watch face, for the use by screen readers.

abstract @NonNull String getInstanceId()

Returns the ID of this watch face instance.

default @NonNull OverlayStyle getOverlayStyle()

The watchface's OverlayStyle which may be null.

Note while this plumbing got built, it was never used by the system ui on any platform and it will be removed.

abstract @NonNull Instant getPreviewReferenceInstant()

The UTC reference preview time for this watch face in milliseconds since the epoch.

@RequiresApi(value = 34)
default @NonNull UserStyleFlavors getUserStyleFlavors()

Returns the watch face's UserStyleFlavors.

abstract @NonNull UserStyleSchema getUserStyleSchema()

The watch face's UserStyleSchema.

default boolean isComplicationDisplayPolicySupported()

Whether or not the watch face supports ComplicationDisplayPolicy. If it doesn't then the client is responsible for emulating it by observing the state of the keyguard and sending NoData complications when the device becomes locked and subsequently restoring them when it becomes unlocked for affected complications.

@AnyThread
abstract boolean isConnectionAlive()

Returns true if the connection to the server side is alive.

default boolean isRemoteWatchFaceViewHostSupported()

Whether or not the watch face supports RemoteWatchFaceViewHost.

abstract void performAmbientTick()

Triggers watch face rendering into the surface when in ambient mode.

@AnyThread
abstract void removeClientDisconnectListener(
    @NonNull InteractiveWatchFaceClient.ClientDisconnectListener listener
)

Removes a ClientDisconnectListener previously registered by addClientDisconnectListener.

@WatchFaceClientExperimental
default void removeOnWatchFaceColorsListener(
    @NonNull Consumer<WatchFaceColors> listener
)

Stops listening for events registered by addOnWatchFaceColorsListener.

abstract void removeOnWatchFaceReadyListener(
    @NonNull InteractiveWatchFaceClient.OnWatchFaceReadyListener listener
)

Stops listening for events registered by addOnWatchFaceReadyListener.

@RequiresApi(value = 27)
abstract @NonNull Bitmap renderWatchFaceToBitmap(
    @NonNull RenderParameters renderParameters,
    @NonNull Instant instant,
    UserStyle userStyle,
    Map<@NonNull Integer, @NonNull ComplicationData> idAndComplicationData
)

Renders the watchface to a shared memory backed Bitmap with the given settings. Note this will be fairly slow since either software canvas or glReadPixels will be invoked.

abstract void sendTouchEvent(@Px int xPosition, @Px int yPosition, int tapType)

Sends a tap event to the watch face for processing.

abstract void setWatchUiState(@NonNull WatchUiState watchUiState)

Updates the watch faces WatchUiState. NB setWatchUiState and updateWatchFaceInstance can be called in any order.

abstract void updateComplicationData(
    @NonNull Map<@NonNull Integer, @NonNull ComplicationData> slotIdToComplicationData
)

Sends new ComplicationData to the watch face. Note this doesn't have to be a full update, it's possible to update just one complication at a time, but doing so may result in a less visually clean transition.

abstract void updateWatchFaceInstance(
    @NonNull String newInstanceId,
    @NonNull UserStyle userStyle
)

Renames this instance to newInstanceId (must be unique, usually this would be different from the old ID but that's not a requirement). Sets the current UserStyle and clears any complication data. Setting the new UserStyle may have a side effect of enabling or disabling complicationSlots, which will be visible via ComplicationSlotState.isEnabled.

NB setWatchUiState and updateWatchFaceInstance can be called in any order.

abstract void updateWatchFaceInstance(
    @NonNull String newInstanceId,
    @NonNull UserStyleData userStyle
)

Renames this instance to newInstanceId (must be unique, usually this would be different from the old ID but that's not a requirement). Sets the current UserStyle represented as a [UserStyleData> and clears any complication data. Setting the new UserStyle may have a side effect of enabling or disabling complicationSlots, which will be visible via ComplicationSlotState.isEnabled.