Detect location on Wear OS

A watch's small, glanceable form factor makes Wear OS by Google an ideal platform for apps that record, report, and respond to user location. As examples, you can build apps that give users real-time updates on their distance, speed, and direction, or provide glanceable queues about users' surroundings.

Refer to the following related resources:

• Make your app location-aware

Some watches have a built-in GPS sensor that retrieves location data without requiring a tethered phone. When you request location data in a watch app, however, you don't have to worry about where the location data originates; the system gets the data via the most power-efficient method. However, as described in sections below, your app does need to handle the loss of location data.

The recommended method of acquiring location data on a watch is to use the Fused Location Provider. Additionally, this document describes how to check for on-watch location sensors, receive location data, and monitor tethered data connections. Also see Location Data for Watches Paired to iPhones.

To reduce the negative impact of location data acquisition on battery life you should ensure your app calls setPriority() set to PRIORITY_BALANCED_POWER_ACCURACY. You should be asking for location no more frequently than once a minute using setInterval().

Note: This document assumes that you know how to use the Google Play services API to retrieve location data.

Use the fused location provider

On a watch, you should get location data using the FusedLocationProviderApi (FLP). The FLP automatically uses location data from the phone if the watch lacks a GPS sensor. For more information, see Create location services client.

For information about requesting location updates and continuously tracking a user's location, see Receive location updates.

Detect on-board GPS

If a user goes jogging with a watch that lacks a built-in GPS sensor, but leaves the paired phone behind, your watch app cannot get location data through a tethered connection. Your app should detect the situation and warn the user that location functionality is unavailable.

To determine if a watch has a built-in GPS sensor, use the hasSystemFeature() method. The following code detects whether the watch has a built-in GPS sensor when you start an activity:

Kotlin

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.main_activity)

    if (!hasGps()) {
        Log.d(TAG, "This hardware doesn't have GPS.")
        // Fall back to functionality that does not use location or
        // warn the user that location function is not available.
    }
}

private fun hasGps(): Boolean =
        packageManager.hasSystemFeature(PackageManager.FEATURE_LOCATION_GPS)

Java

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main_activity);

    if (!hasGps()) {
        Log.d(TAG, "This hardware doesn't have GPS.");
        // Fall back to functionality that does not use location or
        // warn the user that location function is not available.
    }

    ...
}

private boolean hasGps() {
    return getPackageManager().hasSystemFeature(PackageManager.FEATURE_LOCATION_GPS);
}

Handle disconnection events

If a watch has no built-in GPS sensor, the watch abruptly loses its location data stream upon losing the tethered data connection to a phone. If your app expects a constant stream of data, your app must detect the loss of a connection, warn the user, and gracefully degrade in functionality.

To detect the loss of a tethered data connection, use the GetConnectedNodesResult method of the NodeApi. For example:

1. Initialize a GoogleApiClient and create a method that calls the NodeApi, e.g. a method called inspectNodes:

   Kotlin

   private lateinit var googleApiClient: GoogleApiClient
   private var wearableConnected = false
   
   override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)
   
       googleApiClient = GoogleApiClient.Builder(this)
               .addApi(Wearable.API)
               .addConnectionCallbacks(object : GoogleApiClient.ConnectionCallbacks {
                   override fun onConnected(connectionHint: Bundle?) {
                       inspectNodes()
                   }
   
                   override fun onConnectionSuspended(cause: Int) {}
               })
               .build()
   
   }
   
   private fun inspectNodes() {
       Wearable.NodeApi
               .getConnectedNodes(googleApiClient)
               .setResultCallback(this, 1000, TimeUnit.MILLISECONDS)
   }
   

   Java

   private GoogleApiClient googleApiClient;
   private boolean wearableConnected = false;
   
   @Override
   public void onCreate() {
       super.onCreate();
   
       googleApiClient = new GoogleApiClient.Builder(this)
               .addApi(Wearable.API)
               .addConnectionCallbacks(new GoogleApiClient.ConnectionCallbacks() {
                   @Override
                   public void onConnected(Bundle connectionHint) {
                       inspectNodes();
                   }
   
                   @Override
                   public void onConnectionSuspended(int cause) {
                   }
               })
               .build();
   }
   
   private void inspectNodes(){
       Wearable.NodeApi.getConnectedNodes(googleApiClient).setResultCallback(this, 1000, TimeUnit.MILLISECONDS);
   }
   

2. Use the following callback method to get the result of using the inspectNodes method:

   Kotlin

   override fun onResult(getConnectedNodesResult: NodeApi.GetConnectedNodesResult) {
       wearableConnected = false
       getConnectedNodesResult.nodes.forEach { node ->
           wearableConnected = wearableConnected or node.isNearby
       }
       Log.v("TEST", "wearableConnected: $wearableConnected")
   }
   

   Java

   @Override
   public void onResult(NodeApi.GetConnectedNodesResult getConnectedNodesResult) {
       if (getConnectedNodesResult != null && getConnectedNodesResult.getNodes() != null){
           wearableConnected = false;
           for (Node node : getConnectedNodesResult.getNodes()){
               if (node.isNearby()){
                   wearableConnected = true;
               }
           }
       }
       Log.v("TEST", "wearableConnected: " + wearableConnected);
   }
   

Handle location not found

When the GPS signal is lost, you can retrieve the last known location of the user's watch. Retrieving the last known location is helpful when you cannot get a GPS fix, or when the watch lacks built-in GPS and loses its connection with the phone. For more information, see Getting the last known location.