Build a watch face service

A watch face is a service packaged in a Wear OS app. When a user selects an available watch face, the watch face is displayed and the service callback methods are invoked.

When a user installs a Wear OS app that has watch faces, the watch faces are available on the watch via the watch face selector. Alternatively, the user can select a watch face from a companion app on the paired phone.

This page describes how to configure a Wear OS project to include watch faces and how to implement a watch face service.

Refer to the following related resources:

Interactive Watch Faces

Watch face sample

Create a watch face project

To create a project in Android Studio for your watch face:

Click File > New > New project.
In the Create Android Project window, accept the default values and click Next.
In the Target Android Devices window, select only the Wear option, and in the list of SDK versions, select the latest available version. Click Next.
In the Add an Activity to Wear window, select Watch Face and click Next.
In the Configure Activity window, accept the default values and click Finish.

Android Studio creates a project with an app module for your watch face service. For more information about projects in Android Studio, see Create a Project.

Dependencies

The Wearable Support Library provides the necessary classes that you extend to create watch face implementations. The Google Play services client libraries (play-services and play-services-wearable) are required to sync data items between the companion device and the wearable with the Wearable Data Layer API.

Android Studio automatically adds the required entries in your build.gradle files when you create the project in the instructions above.

Wearable support library API reference

The reference documentation provides detailed information about the classes you use to implement watch faces. Browse the API reference documentation for the Wearable Support Library.

Note: We recommend using Android Studio for Wear OS development, as it provides project setup, library inclusion, and packaging conveniences.

Declare permissions

A watch face requires the WAKE_LOCK permission. Add the following permission to the manifest files of both the Wear OS app (wearable app) and the mobile (phone) app under the manifest element:

<manifest ...>
    <uses-permission
        android:name="android.permission.WAKE_LOCK" />

    <!-- Required for complications to receive complication data and open the provider chooser. -->
    <uses-permission
        android:name="com.google.android.wearable.permission.RECEIVE_COMPLICATION_DATA"/>
    ...
</manifest>

Caution: The handheld app must include all of the permissions declared in the wearable app.

Implement the service and callback methods

Watch faces in Wear OS are implemented as services. When a watch face is active, the system invokes the methods in its service when the time changes or when an important event occurs (like switching to ambient mode or receiving a new notification). The service implementation then draws the watch face on the screen using the updated time and any other relevant data.

To implement a watch face, you extend the CanvasWatchFaceService and CanvasWatchFaceService.Engine classes, and then you override the callback methods in the CanvasWatchFaceService.Engine class. These classes are included in the Wearable Support Library.

The following snippet outlines the key methods you need to implement:

Kotlin

class AnalogWatchFaceService : CanvasWatchFaceService() {

    override fun onCreateEngine(): Engine {
        /* provide your watch face implementation */
        return Engine()
    }

    /* implement service callback methods */
    inner class Engine : CanvasWatchFaceService.Engine() {

        override fun onCreate(holder: SurfaceHolder) {
            super.onCreate(holder)
            /* initialize your watch face */
        }

        override fun onPropertiesChanged(properties: Bundle?) {
            super.onPropertiesChanged(properties)
            /* get device features (burn-in, low-bit ambient) */
        }

        override fun onTimeTick() {
            super.onTimeTick()
            /* the time changed */
        }

        override fun onAmbientModeChanged(inAmbientMode: Boolean) {
            super.onAmbientModeChanged(inAmbientMode)
            /* the wearable switched between modes */
        }

        override fun onDraw(canvas: Canvas, bounds: Rect) {
            /* draw your watch face */
        }

        override fun onVisibilityChanged(visible: Boolean) {
            super.onVisibilityChanged(visible)
            /* the watch face became visible or invisible */
        }
    }
}

Java

public class AnalogWatchFaceService extends CanvasWatchFaceService {

    @Override
    public Engine onCreateEngine() {
        /* provide your watch face implementation */
        return new Engine();
    }

    /* implement service callback methods */
    private class Engine extends CanvasWatchFaceService.Engine {

        @Override
        public void onCreate(SurfaceHolder holder) {
            super.onCreate(holder);
            /* initialize your watch face */
        }

        @Override
        public void onPropertiesChanged(Bundle properties) {
            super.onPropertiesChanged(properties);
            /* get device features (burn-in, low-bit ambient) */
        }

        @Override
        public void onTimeTick() {
            super.onTimeTick();
            /* the time changed */
        }

        @Override
        public void onAmbientModeChanged(boolean inAmbientMode) {
            super.onAmbientModeChanged(inAmbientMode);
            /* the wearable switched between modes */
        }

        @Override
        public void onDraw(Canvas canvas, Rect bounds) {
            /* draw your watch face */
        }

        @Override
        public void onVisibilityChanged(boolean visible) {
            super.onVisibilityChanged(visible);
            /* the watch face became visible or invisible */
        }
    }
}

The CanvasWatchFaceService class provides an invalidate mechanism similar to the View.invalidate() method. You can call the invalidate() method throughout your implementation when you want the system to redraw the watch face. You can only use the invalidate() method in the main UI thread. To invalidate the canvas from another thread, call the postInvalidate() method.

For more information about implementing the methods in the CanvasWatchFaceService.Engine class, see Drawing Watch Faces.

Register the watch face service

After you implement the watch face service, you register the implementation in the manifest file of the wearable app. When users install this app, the system uses the information about the service to make the watch face available in the Wear OS companion app and in the watch face picker on the wearable device.

The following snippet shows how to register a watch face implementation under the application element:

<service
    android:name=".AnalogWatchFaceService"
    android:label="@string/analog_name"
    android:permission="android.permission.BIND_WALLPAPER" >
    <meta-data
        android:name="android.service.wallpaper"
        android:resource="@xml/watch_face" />
    <meta-data
        android:name="com.google.android.wearable.watchface.preview"
        android:resource="@drawable/preview_analog" />
    <meta-data
        android:name="com.google.android.wearable.watchface.preview_circular"
        android:resource="@drawable/preview_analog_circular" />
    <intent-filter>
        <action android:name="android.service.wallpaper.WallpaperService" />
        <category
            android:name=
            "com.google.android.wearable.watchface.category.WATCH_FACE" />
    </intent-filter>
</service>

The Wear OS companion app and the watch face picker on the wearable device use the preview image defined by the com.google.android.wearable.watchface.preview metadata entry when presenting users with all the watch faces installed on the device. To obtain this drawable, run the watch face on your Wear OS device or in an emulator instance and take a screenshot. On Wear OS devices with hdpi screens, the preview image is typically 320x320 pixels in size.

Watch faces that look substantially different on round devices can provide both round and square preview images. To specify a round preview image, use the com.google.android.wearable.watchface.preview_circular metadata entry. If a watch face includes both preview images, the companion app and the watch face picker on the wearable show the appropriate one, depending on the shape of the watch. If a round preview image is not included, the square preview image is used for both square and round devices. For round devices, a square preview image is cropped using a circular shape.

The android.service.wallpaper metadata entry specifies the watch_face.xml resource file, which contains a wallpaper element:

<?xml version="1.0" encoding="UTF-8"?>
<wallpaper xmlns:android="http://schemas.android.com/apk/res/android" />

Your wearable app can contain more than one watch face. You must add a service entry to the manifest file of the wearable app for each of your watch face implementations.

Designing watch faces

Drawing watch faces