Introduction to Wear OS

An overview of Wear OS (formerly Android Wear) development and how to take advantage as an Android Developer.

I would like to share my knowledge developing for wearables (smartwatches), coming from Android development with Kotlin and Jetpack Compose.

What is it?

Wear OS is Google’s smartwatch platform, enabling Android devs to build apps for wearable devices. With the rising popularity of fitness and productivity-focused watches, knowing how to build for Wear OS is a valuable skill. In this guide, we’ll go from the basics to publishing your first production-ready Wear OS app.

Setting up the environment

• Install Android Studio (latest stable).
• SDK requirements (API 30+ recommended).
• Emulator setup (Pixel Watch 2 or similar).
• Use Android Studio’s Device Manager to create a Wear OS virtual device.

Optionally: real device (connect via Bluetooth or Wi-Fi debugging).

Project structure

There are two common approaches:

1. Standalone app (only for Wear)
2. Companion + Wear app (phone app with a module for Wear)

In the first case, standalone, we tell the system that our Wear app works independently, meaning it doesn’t require a phone app to function. Many Wear apps manage their state without even needing the phone to be connected. However, unless the app handles some kind of caching on the watch, many of them won’t work properly without relying on the phone’s internet connection. Connectivity plays a very important role, as we’ll see next.

The watch can connect to the outside world in several ways:

Network proxy via phone Bluetooth
In this mode, the watch accesses the internet natively by using the active Bluetooth connection maintained while it’s paired with the phone.

Built-in network connection
On the other hand, higher-end watches go beyond just using the phone’s internet connection. They can also connect to any Wi-Fi network configured on the phone or even manually connect to a different one. Additionally, some models support LTE or cellular networks via a built-in SIM or eSIM, giving them the ability to operate completely independently from Wi-Fi. This means they can make calls and receive messages without needing the phone nearby.

With that in mind, developing a Wear app in standalone mode allows our app to function with or without the phone, depending on the device’s capabilities. This is extremely useful when the business logic is entirely watch-based — for example, a fitness tracker, step counter, calorie tracker, etc.

On the other hand, if our app depends on the companion app being installed on the phone or requires a background service running there, we need to configure the Wear app with standalone = false, like this:

The standalone flag doesn’t restrict the app from working with or without the phone; it simply informs the system — for example, for Google Play — that the app may require the phone to function properly.

Developing apps

If you’re already familiar with native Android development, building for Wear OS will feel very natural. We have access to nearly the same design elements and development tools as in the native Android ecosystem, such as:

• Activities
• Fragments (deprecated)
• ViewModels (allowing MVVM)
• Common libraries such as Dagger Hilt, Room, Retrofit
• Services (Service, TileService, WorkManager)
• Jetpack Compose + XML UI-based
• Intent, BroadCast receiver (with limitations)
• etc

So, you won’t face major issues developing Wear apps — the only thing you really need to focus on is creating an app that people enjoy and making sure it follows Google’s design guidelines for Wear OS.

References/Links

https://developer.android.com/courses/pathways
https://developer.android.com/training/wearables/user-interfaces

---

💬 Your thoughts?
Building a Wear OS app too? Share your experience or questions in the comments — let’s connect! 👇