Add complications to a watch face

A watch face Complication displays data from a data provider. With the Complications API, watch faces can choose the data providers they want to use to get the underlying data. This enables watch faces to display information beyond the time of day without needing code for getting the data.

The Complications API also enables users to select data providers of their choice. Additionally, Wear OS by Google provides a user interface for data source selection.

To add complications to a watch face, do the following:

• Decide how many complication slots you want to include, and what complication types to support in each one.
• Set default data providers for each slot.
• Allow users to choose data providers.
• Set permissions to receive complication data.
• Activate complications to start receiving data.
• Render complications when drawing your watch face.
• Test that complication data is rendered correctly.

Set default providers for watch faces

Watch faces can specify default providers that are used until a user selects a provider. Set default providers using the setDefaultComplicationProvider() method in WatchFaceService.Engine. This method may be called at any time, but it does nothing if the user already chose a provider for the given complication.

For most providers, the RECEIVE_COMPLICATION_DATA permission must be granted to a watch face before data can flow to it. However, some system providers are considered safe because they only supply information that the watch face already could obtain itself. Safe providers do not require you to send permissions to the watch face before data is sent (see System providers). These providers may be preferable to use as defaults, as they can supply data immediately.

Alternatively, if a watch face has a partnership with a certain provider and wishes to use it as a default, it can request that the provider list it as a safe watch face.

System providers

The system includes providers that can be used as defaults. The setDefaultSystemComplicationProvider() method, in the WatchFaceService.Engine class, sets a default system provider for a complication. This method takes an ID (as an integer) that represents a system provider. The available IDs are listed in the SystemProviders class.

The following table has details about some of the supported system providers:

Allow users to choose data providers

Wear OS provides a user interface (via an Activity) that enables users to choose providers for a particular complication. Watch faces can call the createProviderChooserHelperIntent() method to obtain an intent that can be used to show the chooser interface.

When a watch face calls createProviderChooserHelperIntent, the watch face supplies a watch face complication ID and a list of supported types. List the types in order of preference, usually with types offering more information, such as ranged value, given higher preference.

When the user selects a data provider, the configuration is saved automatically; nothing more is required from the watch face.

See the Watch Face sample app for the full-featured, recommended code for the settings user interface.

That code includes:

• A standard interface for complication settings.
• Easy access to other settings.

A starting point for reviewing that code is the AnalogComplicationConfigActivity class, which has a getDataToPopulateAdapter() method that returns a list of the settings entries available in the UI.

Open the provider chooser

A watch face must have the following permission to receive complication data and open the provider chooser:

com.google.android.wearable.permission.RECEIVE_COMPLICATION_DATA

A watch face that was not granted the above permission will be unable to start the provider chooser.

To make it easier to request the permission and start the chooser, the ComplicationHelperActivity class is available in the wearable support library. Use this class instead of the ProviderChooserIntent class to start the chooser in almost all cases.

Request the necessary permission

To use ComplicationHelperActivity, add it to the watch face in the manifest file:

<activity android:name="android.support.wearable.complications.ComplicationHelperActivity"/>

To start the provider chooser, call the ComplicationHelperActivity.createProviderChooserHelperIntent method, to obtain an intent.

Use the new intent with either startActivity or startActivityForResult to launch the chooser.

Here is an example of using the new intent with startActivityForResult:

startActivityForResult(
        ComplicationHelperActivity.createProviderChooserHelperIntent(
                activity,
                watchFace,
                complicationId,
                ComplicationData.TYPE_LARGE_IMAGE
        ),
        PROVIDER_CHOOSER_REQUEST_CODE
)

startActivityForResult(
  ComplicationHelperActivity.createProviderChooserHelperIntent(
     getActivity(),
     watchFace,
     complicationId,
     ComplicationData.TYPE_LARGE_IMAGE),
  PROVIDER_CHOOSER_REQUEST_CODE);

When the helper activity is started, the helper activity checks if the permission was granted. If the permission was not granted, the helper activity makes a runtime permission request. If the permission request is accepted (or is unneeded), the provider chooser is shown.

If startActivityForResult was used with the intent, the result delivered back to the calling Activity will have a result code of RESULT_OK if a provider was successfully set, or a result code of RESULT_CANCELLED if no provider was set.

In the case where a provider was set, ComplicationProviderInfo class for the chosen provider will be included in the data intent of the result, as an extra with the key ProviderChooserIntent#EXTRA_PROVIDER_INFO.

Receive complication data

To start receiving complication data, a watch face calls setActiveComplications(), in the WatchFaceService.Engine class, with a list of watch face complication IDs. A watch face creates these IDs to uniquely identify slots on the watch face where complications can appear, and passes them to the createProviderChooserIntent() method to allow the user to decide which complication should go in which slot. Complication data is delivered via the onComplicationDataUpdate() callback.

In general, watch faces need the above permission in order to receive complication data, but there are some exceptions. Specifically, a watch face can only receive data from a provider if one of the following is true:

• The provider is a "safe" system provider.
• The provider and watch face are from the same app.
• The provider lists the watch face as a "safe" watch face.
• The watch face has the permission.

If none of the above is true, then when ComplicationData normally would be sent by a provider to a watch face, the system instead sends data of the type TYPE_NO_PERMISSION. This type includes an icon (an exclamation mark) and short text ("--") to allow it to be rendered as if it were of the short text type or icon type, for convenience.

When a watch face receives data of TYPE_NO_PERMISSION, the watch face should render this appropriately, so the user can see that action is needed for the complication to work. If possible, a tap on a complication in this state should launch a permission request. Use the ComplicationHelperActivity.createPermissionRequestHelperIntent() to do this, if the helper activity was added to the watch face app.

If a user accepts the permission request created by the helper activity, updates are requested for all the active complications on the watch face automatically, allowing the TYPE_NO_PERMISSION data to be replaced by real data.

Render complications

The watch face may render the data as desired as long as the expected fields are represented. For more information on which fields to include, see the Notes column in the table below.

We provide design guidelines for our style, as a suggestion for standard complications, but developers can use their own styles or incorporate the data into the watch face in different ways.

Draw complications

The ComplicationDrawable class enables you to render an entire complication on a canvas.

The class supports all six of the main complication types, and does the following for you:

• Handles all aspects of layout and styling for complications.
• Draws backgrounds, icons, text, etc., within bounds.
• Allows you to set many options. These include, but are not limited to, options for the following: background color, corner shape and radius, border (or lack of a border), text color, and typeface.
• Decodes and caches images.

If you target API level 24, a ComplicationDrawable object can be defined in XML as a resource. Alternatively, you can create a ComplicationDrawable object programmatically. You use the draw() method to draw a complication and set style options for the interactive and ambient modes.

ComplicationDrawable will use burn-in safe icons and images if they have been provided and the device requires them. To enable this, call the ComplicationDrawable.setBurnInProtection() method when the device properties are received.

For detailed instructions and examples for drawing complications, see ComplicationDrawable, which includes sample XML. For a sample watch face that utilizes this class and includes sample XML, see the AnalogComplicationWatchFaceService sample in the Watch Face sample app.

If you don't use a ComplicationDrawable object, use TextRenderer for the text of a complication.

Render text

The TextRenderer class is intended for use in complications, and eases the drawing of text on a canvas. The class includes these features:

• If seven characters (the maximum in the short text field) do not fit in the bounds at the requested text size, the class shrinks the text until it fits.
• Text can be flowed over a specified number of lines.
• Text can be ellipsized if it does not fit.
• Rendering is adjusted for an always-on screen (ambient mode).

When you initialize your watch face engine, you can create a TextRenderer object and pass in the TextPaint object that you want the TextRenderer object to use. The TextPaint object defines the font, text size, color, and more. You should create a TextRenderer object for each field, e.g. one for a text field and one for a title field.

For example code, including for specifying bounds on the text you want to render, see TextRenderer.

Tap on complications

Use the ComplicationDrawable.onTap() method to enable your watch face to pass tap events to complications. This method builds on the functionality in which a tap on the watch face triggers the WatchFaceService.Engine.onTapCommand() method.

You can pass coordinates to a ComplicationDrawable with an onTap call. This will launch the action associated with the ComplicationDrawable that contains the tap coordinates. When the method is called, you will receive a return value of true if a ComplicationDrawable launched the associated action.

Use the setHighlightDuration() method to set the duration for a complication to remain highlighted after the onTap method is called.

If you are not using ComplicationDrawable for a complication, you will need to detect taps and fire the tap action PendingIntent yourself. See Create interactive watch faces to learn how to create watch faces that respond to user taps.

Complication types

Complication types determine the kinds of data shown in a complication. For example, the SHORT_TEXT type is available when the key data is a short string. In the example of the SHORT_TEXT type, optional data are an icon and a short title.

Data providers use these complication types differently from the way watch face providers use these types:

• A data provider chooses the types of complication data to supply. For example, a step count provider might support the RANGED_VALUE and SHORT_TEXT types, whereas a "next meeting" provider might support the SHORT_TEXT and LONG_TEXT types. The data provider also chooses which optional fields of those types to include.
• A watch face provider chooses how many complication types to support. For example, a round complication on a watch face might support the SHORT_TEXT, ICON and RANGED_VALUE types, whereas a gauge on the watch face might support only the RANGED_VALUE type.

A ComplicationData object will always have a single complication type. Each complication type has required and optional fields. Generally, a required field represents the primary piece of data; most types take their name from the required field.

A given type may include different sets of fields. For example, SHORT_TEXT may be just a single piece of text, or a title and text, or an icon and text. A complication that supports a given type must have the ability to display all the expected variants. However, you may not need to display some optional fields (see the Notes column of the table below). For example, the Short title field of the RANGED_VALUE type is not required so that, for example, gauges can be shown without including text.

Examples of Complication Types

The following shows examples of complication types:

Types and fields

The following table describes the types and fields of the ComplicationData object. If a watch face requests a field that is invalid for a complication type, a default value for the field is returned. For example, if a watch face tries to access a Long text field in a SHORT_TEXT type, the default value for the Long text field (null) is returned.

The types in the table below are for empty data and may be sent for any complication slot. These types have no fields and do not need to be included in a list of supported types. These types enable watch faces to differentiate among the following three cases:

• No provider was chosen
• The user has selected "empty" for a slot
• A provider has no data to send

Providers should not send TYPE_EMPTY in response to update requests. Providers should send TYPE_NO_DATA instead.

Details on the complication types for "empty" data are in the following table:

Use fields for complication data

The fields of a ComplicationData object have different functions. For example, a text field contains the primary data while a title field is descriptive; a step count complication might have a text field value of "2,543" with a title field value of "steps."

The following table contains descriptions of the fields in a ComplicationData object. The fields may or may not be populated, depending on the complication type.

Test complication types

Each complication type has fields, such as text and icons. If your watch face supports a complication type, you need to support all of the valid field combinations.

You can test the way complication data is displayed on a watch face. Specifically, a test suite enables you to test the display of the complication types. Thus, you don't need to write code to test the valid field combinations for a ComplicationData object.

The test suite is a data provider, available as a sample, which cycles through the valid field combinations for a given complication type.

To use the test suite:

1. Install the test suite APK on a device or emulator.
2. Access your watch face and tap its main settings icon.
3. Use the settings UI to choose the test suite: WearComplication-ProviderTestSuite
4. Choose a complication data type to test.
5. Tap your complication to view the variations of the data type.
6. Repeatedly tap your complication to verify that all relevant field combinations are properly displayed.

For example, if a complication supports short text, tap your complication to see all the main combinations of fields for short text.

Related resources