Posted by Michael Stillwell – Developer Relations Engineer
This post is part of Wear OS Spotlight Week. Today, we're focusing on creating engaging experiences across the various surfaces available on the wrist.
Developing for the growing ecosystem of Wear OS is a unique and rewarding challenge that encourages you to think beyond mobile patterns. Wear's design philosophy focuses on crafting experiences for a device that's always with the user, where meaningful interactions take seconds, not minutes. A successful wearable app doesn't attempt to maximize screen time; it instead aims to deliver meaningful glanceable experiences that help people stay present and productive while on the go. This vision is now fully enabled by the next generation of hardware, which we explored last week with the introduction of the new Pixel Watch 4.
Wear OS devices also introduce constraints that push you to innovate. Power efficiency is critical, requiring you to build experiences that are both beautiful and battery-conscious. You'll also tackle challenges like handling offline use cases and catering for a variety of screen sizes.
Despite these differences, you'll find yourself on familiar technical foundations. Wear OS is based on Android, which means you can leverage your existing knowledge of the platform, architecture, developer APIs, and tools to create wearable experiences.
Wear OS surfaces
Wear OS offers a range of surfaces to inform and engage users. This allows you to tailor your app's presence on the watch, providing the right information at the right time and scaling your development investment to best meet your users' needs.
Watch faces display the time and are the first thing a user sees when they look at their watch. We'll cover watch faces in more detail in other blog posts across Wear OS Spotlight week.
The Watch face is the first thing a user sees when they look at their watch
Apps provide a richer, more immersive UI for complex tasks that are too involved for other surfaces.
Apps support complex tasks and can scroll vertically
Notifications provide glanceable, time-sensitive information and actions.
A notification provides glanceable, time-sensitive information
Complications display highly-glanceable, relevant data from your app directly on the user's chosen watch face. Learn more about building complication data sources for Wear OS.
Complications display glanceable data from your app directly on the user's watch face.
Tiles (Widgets for Wear OS) offer fast, predictable access to information and actions with a simple swipe from the watch face.
Tiles offer fast, predictable information and actions
Whilst a variety of Wear OS surfaces let developers to engage with users in different ways, it may be overwhelming to get started. We recommend approaching Wear OS development in phases and scale up your investment over time:
Recommended Wear OS development phases: enhance the wearable experience of your Android app, build Tiles and complications, and then create a complete wearable experience.
Improve the wearable experience of your mobile app. You can improve the wearable experience with minimal effort. By default, notifications from your phone app are automatically bridged to the watch. You can start by enhancing these with wearable-specific actions using NotificationCompat.WearableExtender, offering a more tailored experience without building a full Wear OS experience.
Build a companion experience. When you're ready for a dedicated UI, create a tethered app experience that depends on the phone app for its core features and data. This involves creating a tethered app that works in tandem with your phone app, allowing you to design a customized UI for the wrist and take advantage of surfaces like tiles and complications.
Graduate to a standalone app. Finally, you can evolve your app into a standalone experience that works independently of a phone, which is ideal for offline scenarios like exercising. This provides the most flexibility but also requires more effort to optimize for constraints like power efficiency.
Notifications
Notifications are a core part of the Wear OS experience, delivering glanceable, time-sensitive information and actions for the user. Because Wear OS is based on Android, it shares the same notification system as mobile devices, letting you leverage your existing knowledge to build rich experiences for the wrist.
From a development perspective, it helps to think of a notification not as a simple alert, but as a declarative UI data structure that is shared between the user's devices. You define the content and actions, and the system intelligently renders that information to best suit the context and form factor. This declarative approach has become increasingly powerful. On Wear OS, for example, it's the mechanism behind ongoing activities.
Alert-style notifications
One great thing about notifications is that you don't even need a Wear OS app for your users to see them on their watch. By default, notifications generated by your phone app are automatically "bridged", or mirrored, to a connected watch, providing an instant wearable presence for your app with no extra work. These bridged notifications include an action to open the app on the phone.
You can enhance this default behavior by adding wearable-specific functionality to your phone notifications. Using NotificationCompat.WearableExtender, you can add actions that only appear on the watch, offering a more tailored experience without needing to build a full Wear OS app.
// Prerequisites:
//
// 1. You've created the notification channel CHANNEL_ID
// 2. You've obtained the POST_NOTIFICATIONS permission
val channelId = "my_channel_id"
val sender = "Clem"
val subject = "..."
val notification =
NotificationCompat.Builder(applicationContext, channelId)
.apply {
setContentTitle("New mail from $sender")
setContentText(subject)
setSmallIcon(R.drawable.new_mail_mobile)
// Added for Wear OS
extend(
NotificationCompat.WearableExtender().apply {
setSmallIcon(R.drawable.new_mail_wear)
}
)
}
.build()
NotificationManagerCompat.from(applicationContext).notify(0, notification)
Prevent duplicate notifications
Once you build a dedicated app for Wear OS, you'll need to develop a clear notification strategy to avoid a common challenge: duplicate notifications. Since notifications from your phone app are bridged by default, a user with both your phone and watch apps installed could see two alerts for the same event.
Wear OS provides a straightforward way to manage this:
On the mobile app's notification, assign a string identifier using setBridgeTag().
In your Wear OS app, you can then programmatically prevent notifications with certain tags from being bridged using a BridgingConfig. This gives you fine-grained control, allowing you to bridge some notifications while handling others natively in your Wear OS app.
If your mobile and watch apps generate similar but distinct notifications, you can link them using setDismissalId(). When a user dismisses a notification on one device, any notification with the same dismissal ID on another connected device is also dismissed.
Creating interactive experiences
From a user's perspective, apps and tiles may feel very similar. Both are full-screen experiences that are visually rich, support animations, and handle user interaction. The main differences are in how they are launched, and their specific capabilities:
Apps can be deeply immersive and handle complex, multi-step tasks. They are the obvious choice when handling data that must be synced between the watch app and its associated phone app, and the only choice for long-running tasks like tracking workouts and listening to music.
Tiles are designed for fast, predictable access to the information and actions users need most, providing glanceable content with a simple swipe from the watch face. Think of tiles as widgets for Wear OS.
Apps and tiles are built using distinct technologies. Apps can be built with Jetpack Compose, while tiles are defined declaratively using the ProtoLayout library. This distinction allows each surface to be highly optimized for its specific role – apps can provide rich, interactive experiences while tiles remain fast and power-efficient.
Building apps
Apps provide the richest experience on Wear OS. Jetpack Compose for Wear OS is the recommended UI toolkit for building them – it works seamlessly with other Jetpack libraries and accelerates development productivity. Many prominent apps, like Gmail, Calendar and Todoist, are built entirely with Compose for Wear OS.
Compose for Wear OS for beautiful UIs
If you've used Jetpack Compose for mobile development, you'll find that Compose for Wear OS shares the same foundational principles and mental model. However, building for the wrist requires some different techniques, and the toolkit provides a specialized UI component library optimized for watches.
Wear OS has its own dedicated Material Design, foundation, and navigation libraries to use instead of the mobile Jetpack libraries. These libraries provide UI components tailored for round screens and glanceable interactions, and are each supported by Android Studio's preview system.
Lists: On mobile, you might use a LazyColumn to display a vertical collection of items. On Wear OS, the TransformingLazyColumn is the equivalent component. It supports scaling and transparency effects to items at the edge of a round screen, improving legibility. It also has built-in support for scrolling with rotary input.
Navigation: Handling screen transitions and the back stack also requires a component that’s specific to Wear OS. Instead of the standard NavHost, you must use SwipeDismissableNavHost. This component works with the system's swipe-to-dismiss gesture, ensuring users can intuitively navigate back to the previous screen.
Learn how to use Jetpack Compose on Wear OS to get started, including sample code.
Implementing core app features
Wear OS also provides APIs designed for power efficiency and the on-wrist use case, as well as Wear OS versions of mobile APIs:
Authentication: Credential Manager API unifies the user sign-in process and supports modern, secure methods like passkeys, passwords, and federated identity services (like Sign-in with Google), providing a seamless and secure experience without relying on a companion phone.
Ambient: To handle the low-power ambient (always-on) state, we recommend using the AmbientLifecycleObserver to receive callbacks for state transitions. In the onEnterAmbient() callback, adjust your UI for low-power display by dimming colors and hiding non-essential elements. Use onExitAmbient() to restore your app's full UI. Learn more about always-on apps and system ambient mode.
Health and Fitness (sensor data): While you can use the standard Android Sensor APIs, it's not recommended for performance reasons, especially for long-running workouts. Instead, use Health Services on Wear OS. It acts as an intermediary to the various sensors, providing your app with batched, power-efficient updates for everything from heart rate to running metrics, without needing to manage the underlying sensors directly.
Building tiles
Tiles offer quick, predictable access to the information and actions users need most, accessible with a simple swipe from the watch face. By using platform data bindings to display sources like step count or heart rate, you can provide timely and useful information in your tile.
Tiles are built declaratively using the ProtoLayout libraries, which are optimized for performance and power efficiency—critical considerations on a wearable device. Learn more about how to get started with tiles and how to make use of sample tile layouts.
More resources for building experiences for Wear OS
Wear OS Documentation Hub: The essential resource for developers looking to create experiences for Wear OS, from design guidelines to code samples.
App design guidance: The official resource to learn how to design for Wear OS.
Compose starter sample app: A starter project that provides a solid foundation for a new Wear OS app.
Media sample app from Jetcaster: A sample podcast app showcasing how to reuse code between form factors, updated to Material 3 Expressive on Wear OS.
WearTilesKotlin sample app: Demonstrates the fundamentals of building a tile but also includes templates for common layouts, letting you quickly bootstrap your own designs while following best practices.
Compose on Wear OS codelab: A step-by-step tutorial for building a functional app for Wear OS from scratch.
Tiles on Wear OS codelab: For a more guided, step-by-step introduction to building tiles.
There has never been a better time to start building for Wear OS. If you have feedback on the APIs, please let us know using the issue trackers for Wear Compose and Tiles. We look forward to seeing what you build!
