Posted by Garan Jenkin – Developer Relations Engineer
A few months ago we relaunched Androidify as an app for generating personalized Android bots. Androidify transforms your selfie photo into a playful Android bot using Gemini and Imagen.
However, given that Android spans multiple form factors, including our most recent addition, XR, we thought, how could we bring the fun of Androidify to Wear OS?
An Androidify watch face
As Androidify bots are highly-personalized, the natural place to showcase them is the watch face. Not only is it the most frequently visible surface but also the most personal surface, allowing you to represent who you are.
Androidify now has the ability to generate a watch face dynamically within the phone app and then send it to your watch, where it will automatically be set as your watch face. All of this happens within seconds!
High-level design
In order to achieve the end-to-end experience, a number of technologies need to be combined together, as shown in this high-level design diagram.
First of all, the user’s avatar is combined with a pre-existing Watch Face Format template, which is then packaged into an APK. This is validated – for reasons which will be explained! – and sent to the watch.
On being received by the watch, the new Watch Face Push API – part of Wear OS 6- is used to install and activate the watch face.
Let’s explore the details:
Creating the watch face templates
The watch face is created from a template, itself designed in Watch Face Designer. This is our new Figma plugin that allows you to create Watch Face Format watch faces directly within Figma.
The plugin allows the watch face to be exported in a range of different ways, including as Watch Face Format (WFF) resources. These can then be easily incorporated as assets within the Androidify app, for dynamically building the finalized watch face.
Packaging and validation
Once the template and avatar have been combined, the Portable Asset Compiler Kit (Pack) is used to assemble an APK.
In Androidify, Pack is used as a native library on the phone. For more details on how Androidify interfaces with the Pack library, see the GitHub repository.
As a final step before transmission, the APK is checked by the Watch Face Push validator.
This validator checks that the APK is suitable for installation. This includes checking the contents of the APK to ensure it is a valid watch face, as well as some performance checks. If it is valid, then the validator produces a token.
This token is required by the watch for installation.
Sending the watch face
The Androidify app on Wear OS uses WearableListenerService to listen for events on the Wearable Data Layer.
The phone app transfers the watch face by using a combination of MessageClient to set up the process, then ChannelClient to stream the APK.
Installing the watch face on the watch
Once the watch face is received on the Wear OS device, the Androidify app uses the new Watch Face Push API to install the watch face:
val wfpManager =
WatchFacePushManagerFactory.createWatchFacePushManager(context)
val response = wfpManager.listWatchFaces()
try {
if (response.remainingSlotCount > 0) {
wfpManager.addWatchFace(apkFd, token)
} else {
val slotId = response.installedWatchFaceDetails.first().slotId
wfpManager.updateWatchFace(slotId, apkFd, token)
}
} catch (a: WatchFacePushManager.AddWatchFaceException) {
return WatchFaceInstallError.WATCH_FACE_INSTALL_ERROR
} catch (u: WatchFacePushManager.UpdateWatchFaceException) {
return WatchFaceInstallError.WATCH_FACE_INSTALL_ERROR
}
Androidify uses either the addWatchFace or updateWatchFace method, depending on the scenario: Watch Face Push defines a concept of “slots” – how many watch faces a given app can have installed at any time. For Wear OS 6, this value is in fact 1.
Androidify’s approach is to install the watch face if there is a free slot, and if not, any existing watch face is swapped out for the new one.
Setting the active watch face
Installing the watch face programmatically is a great step, but Androidify seeks to ensure the watch face is also the active watch face.
Watch Face Push introduces a new runtime permission which must be granted in order for apps to be able to achieve this:
com.google.wear.permission.SET_PUSHED_WATCH_FACE_AS_ACTIVE
Once this permission has been acquired, the wfpManager.setWatchFaceAsActive() method can be called, to set an installed watch face to being the active watch face.
However, there are a number of considerations that Androidify has to navigate:
-
setWatchFaceAsActive can only be used once.
-
SET_PUSHED_WATCH_FACE_AS_ACTIVE cannot be re-requested after being denied by the user.
-
Androidify might already be in control of the active watch face.
For more details see how Androidify implements the set active logic.
Get started with Watch Face Push for Wear OS
Watch Face Push is a versatile API, equally suited to enhancing Androidify as it is to building fully-featured watch face marketplaces.
Perhaps you have an existing phone app and are looking for opportunities to further engage and delight your users?
Or perhaps you’re an existing watch face developer looking to create your own community and gallery through releasing a marketplace app?
Take a look at these resources:
And also check out the accompanying video for a greater-depth look at how we brought Androidify to Wear OS!
We’re looking forward to what you’ll create with Watch Face Push!