We recommend that Wear OS apps work independently of a phone so users can
complete tasks on a watch without access to an Android or iOS phone.
If your watch app
requires phone interaction, you must mark your Wear OS app as non-standalone
and take steps to ensure that the user has the phone app available.

## Plan your app


You can use [Android App Bundle](https://developer.android.com/guide/app-bundle)
to automatically generate optimized Android Package Kits (APKs) for each user's device configuration under the same
application listing. This lets users download only the code and resources they need to
run your app.


For information about setting up your app for distribution through
the Google Play Store, see [Package and distribute Wear OS Apps](https://developer.android.com/training/wearables/packaging) and the guide to getting started with
[Android App Bundles](https://developer.android.com/guide/app-bundle#get_started).


For new apps, the target API level must be 30 or higher. For more information, see
[Meet Google Play's target API
level requirement](https://developer.android.com/google/play/requirements/target-sdk). Set the
`targetSdkVersion` to API level 30 (Wear OS 3) to help ensure that your app works well
on the latest platform version.


For information about network requests and high-bandwidth network access,
see [Network access and sync on Wear OS](https://developer.android.com/training/wearables/data-layer/network-access).

### Define an app as a Wear OS app


You must define the [<uses-feature>](https://developer.android.com/guide/topics/manifest/uses-feature-element) tag in your app's Android manifest file.
To indicate that it is a watch app, add an entry like the following:

```carbon
  <manifest>
  ...
  <uses-feature android:name="android.hardware.type.watch" />
  ...
  </manifest>
  
```

### Identify an app as standalone or non-standalone


A watch app is considered either standalone or non-standalone:

- **Standalone**: a completely independent app that doesn't require a phone app for core features. Although "Open on phone" prompts are acceptable, the app must provide alternative means for users to complete an app function---such as a shortlink or QR code---without depending on a tethered phone.
- **Non-standalone**: a dependent app that requires an app on a phone or another device for core features. This option is best for apps when they can't easily provide an alternative means---such as a QR code or shortlink---for completing a core app function, such as authentication.

**Note:** Even for non-standalone apps, users can install the
Wear OS app before the mobile app. So if your Wear OS app detects that a
nearby handheld device lacks the necessary companion app, prompt the user
to install the companion app.

Google validates the accuracy of an app's standalone status during app
serving. This value affects the visibility of apps within the Play Store on
untethered devices, such as Wear OS devices that aren't paired to handheld
devices. Non-standalone apps---as well as apps that developers incorrectly
designate as "standalone"---aren't available to users on these untethered
devices.


In your Wear OS app, set the value of `
`[meta-data](https://developer.android.com/guide/topics/manifest/meta-data-element) element `com.google.android.wearable.standalone`
in the Android manifest file to declare whether your app is standalone or non-standalone.


If your watch app is a completely independent, standalone app, indicate
this to the Google Play store by setting the
value of `com.google.android.wearable.standalone` to `true`:  

```xml
<application>
...
  <meta-data
    android:name="com.google.android.wearable.standalone"
    android:value="true" />
...
</application>
```


If your watch app is non-standalone and depends on another app for core features,
set the value of `com.google.android.wearable.standalone` to
`false`. This signifies that the watch app requires another device, but doesn't
affect your app promotion on the Google Play Store.


**Note:**
Even if the value of `com.google.android.wearable.standalone` is
`false`, the watch
app can be installed before the phone app is installed.
Therefore, if your watch app
[detects](https://developer.android.com/training/wearables/apps/standalone-apps#detecting-your-app) that a companion phone
lacks the necessary phone app, as described on this page,
prompt the user to install the phone app.

## Shared code and data storage


Code can be shared between a Wear OS app and a phone app.
For example, common code for networking can be in a shared library.


Optionally, code
that is specific to a form factor can be in a separate module.


You can use standard Android storage APIs to store data locally, as you
would on a phone. For example, you can use the
[SharedPreferences
APIs](https://developer.android.com/reference/android/content/SharedPreferences) or the [Room](https://developer.android.com/training/data-storage/room)
persistence library.

## Detect your app on another device


Your watch app and corresponding phone app
can each detect whether the other app is available.


Your phone and watch apps can use the
[`CapabilityClient`](https://developers.google.com/android/reference/com/google/android/gms/wearable/CapabilityClient) to advertise their presence
to a paired device. They can do so statically or dynamically.


When an app
is on a node in a user's Wear OS network, such as on a phone, paired watch, or
in the cloud, the `CapabilityClient` lets other
apps detect it. For more information, see
[Advertise capabilities](https://developer.android.com/training/wearables/data-layer/messages#advertise-capabilities).


If one of your apps can't detect the other, you can prompt
the user to open the Play Store listing on the affected device.
This is a solution for watch apps that require their
companion phone app's presence to function properly.


You must check whether the Play Store is available on
the device, because not all phones---such as iPhones---support the
Play Store.


The following sections describe best practices for two scenarios:

- Your standalone watch app needs your phone app.
- Your phone app needs your standalone watch app.


You can also review the [Datalayer helpers sample](https://github.com/google/horologist/tree/v0.6.10/datalayer/sample), which shows how to use the
[Datalayer helpers libraries](https://google.github.io/horologist/datalayer-helpers-guide/), part of [Horologist](https://google.github.io/horologist/). These helpers let you monitor the connection between a handheld
device and a Wear OS device.
For more information
about the classes described in the following section, see the
[Wear OS API reference](https://developer.android.com/reference/packages-wearable-support).
That reference also includes information about the
[`PhoneTypeHelper`](https://developer.android.com/reference/kotlin/androidx/wear/phone/interactions/PhoneTypeHelper) class, which contains a
[`getPhoneDeviceType()`](https://developer.android.com/reference/kotlin/androidx/wear/phone/interactions/PhoneTypeHelper#getPhoneDeviceType(android.content.Context)) method that lets your
Wear OS app check whether a companion phone is an Android or iOS device.

### Specify capability names for detecting your apps


For the app corresponding to each device type, either watch or phone, specify a
unique string for the capability name in the
`res/values/wear.xml` file.


For example, in your mobile module, the `wear.xml` file
could include the following:  

```xml
<resources xmlns:tools="http://schemas.android.com/tools"
        tools:keep="@array/android_wear_capabilities">
    <string-array name="android_wear_capabilities">
        <item>verify_remote_example_phone_app</item>
    </string-array>
</resources>
```


In your Wear OS module, the `wear.xml` file includes a
different value for the capability name,
such as the following:  

```xml
<resources xmlns:tools="http://schemas.android.com/tools"
        tools:keep="@array/android_wear_capabilities">
    <string-array name="android_wear_capabilities">
        <item>verify_remote_example_wear_app</item>
    </string-array>
</resources>
```


For more information, see [Advertise capabilities](https://developer.android.com/training/wearables/data-layer/messages#advertise-capabilities).

### App detection and opening a URL from a watch

Your watch app can detect whether a user's companion phone has your
phone app. Follow these steps:

1. Use the `CapabilityClient` to check whether your phone app is installed on the paired phone. For more information, see the [Datalayer helpers sample](https://github.com/google/horologist/tree/v0.6.10/datalayer/sample) on GitHub.
2. If your phone app isn't installed on the phone, use the [`PhoneDeviceType.getPhoneDeviceType()`](https://developer.android.com/reference/kotlin/androidx/wear/phone/interactions/PhoneTypeHelper#getPhoneDeviceType(android.content.Context)) method to check the type of the phone. See the following section for details.
3. If [`PhoneDeviceType.DEVICE_TYPE_ANDROID`](https://developer.android.com/reference/kotlin/androidx/wear/phone/interactions/PhoneTypeHelper#DEVICE_TYPE_ANDROID()) is returned, the phone is an Android phone. Call [`RemoteActivityHelper.startRemoteActivity()`](https://developer.android.com/reference/kotlin/androidx/wear/remote/interactions/RemoteActivityHelper#startRemoteActivity(android.content.Intent,kotlin.String)) on the Wear OS device to open the Play Store on the phone. Use the market URI for your phone app, which might be different from your Wear app's URI. For example, use a market URI such as: `market://details?id=com.example.android.wearable.wear.finddevices`.
4. If
   [`PhoneDeviceType.DEVICE_TYPE_IOS`](https://developer.android.com/reference/kotlin/androidx/wear/phone/interactions/PhoneTypeHelper#DEVICE_TYPE_IOS())
   is returned, the phone is an iOS phone with no Play
   Store available. Open the App Store on the iPhone
   by calling `RemoteActivityHelper.startRemoteActivity()` on the Wear
   OS device. You can specify your app's iTunes URL, such as
   `https://itunes.apple.com/us/app/yourappname`.

   From Wear OS, you cannot programmatically determine whether
   your phone app is installed on an iOS device. As a best practice, provide a
   mechanism to the user to manually trigger the
   opening of the App Store.


**Note** : Use the `RemoteActivityHelper` API previously described to
specify that any URL be opened on the phone from the watch,
and that no phone app is required.

### Details for detecting the type of paired phone


Here is a snippet that uses the `getPhoneDeviceType()` method to
check the type of phone to which the watch is paired:  

### Kotlin

```kotlin
var phoneDeviceType: Int = PhoneDeviceType.getPhoneDeviceType(context)
```

### Java

```java
int phoneDeviceType = PhoneDeviceType.getPhoneDeviceType(context);
```


The value returned by the `getPhoneDeviceType()`
method is one of the following:

| **Return value** | **Description** |
|---|---|
| [`DEVICE_TYPE_ANDROID`](https://developer.android.com/reference/kotlin/androidx/wear/phone/interactions/PhoneTypeHelper#DEVICE_TYPE_ANDROID()) | The companion phone is an Android device. |
| [`DEVICE_TYPE_IOS`](https://developer.android.com/reference/kotlin/androidx/wear/phone/interactions/PhoneTypeHelper#DEVICE_TYPE_IOS()) | The companion phone is an iOS device. |
| [`DEVICE_TYPE_UNKNOWN`](https://developer.android.com/reference/kotlin/androidx/wear/phone/interactions/PhoneTypeHelper#DEVICE_TYPE_UNKNOWN()) | The companion phone is an unknown device. |
| [`DEVICE_TYPE_ERROR`](https://developer.android.com/reference/kotlin/androidx/wear/phone/interactions/PhoneTypeHelper#DEVICE_TYPE_ERROR()) | An error occurred in determining the type of the paired phone; another check should be made later. |

### App detection starting from an Android phone


Your Android phone can detect whether a user's Wear OS devices have your
watch app. Follow these steps:

1. Using the [`NodeClient`](https://developers.google.com/android/reference/com/google/android/gms/wearable/NodeClient), find all watches connected to the user's phone. For more information, see the [Datalayer helpers sample](https://github.com/google/horologist/tree/v0.6.10/datalayer/sample) on GitHub.
2. Using the `CapabilityClient`, check which of the user's watches has your app installed.
3. If your app isn't installed on all of the user's watches, let the user open the Play Store on the remaining Wear OS devices from the phone using the `RemoteActivityHelper.startRemoteActivity()` method. Use the market URI for the Wear OS app, which might be different from your phone app's URI. For example, use a market URI such as: `market://details?id=com.example.android.wearable.wear.finddevices`.

## Location data for watches paired to iPhones


For watches paired with iPhones, use the
[Fused Location Provider (FLP)](https://developers.google.com/android/reference/com/google/android/gms/location/FusedLocationProviderClient) to get location data on the watch.
For more information, see
[Detect location on Wear OS](https://developer.android.com/training/articles/wear-location-detection).


If the companion phone is available, FLP uses the companion phone for
location data.

## Obtain only necessary data


Generally, when obtaining data from the internet, get only the
necessary data. Otherwise, you may introduce unnecessary latency, memory
use, and battery use.


When a watch is connected over a Bluetooth LE connection, your app might
have access to a bandwidth of only 4 kilobytes per second, depending
on the watch. Therefore, the following steps are recommended:

- Audit your network requests and responses for extra data that is only needed for a phone app.
- Shrink large images before you send them over a network to a watch.


For cases where a high-bandwidth network is needed, see
[High-bandwidth network access](https://developer.android.com/training/wearables/data-layer/network-access#high-bandwidth-network-access).

## Additional code samples


The
[Datalayer helpers sample](https://github.com/google/horologist/tree/v0.6.10/datalayer/sample) further demonstrates the use of the APIs covered on this page.