Guide for Android Developers on Using the Google Location Services API

Understanding a user’s whereabouts is valuable for many apps we use daily. Numerous location-based apps are simplifying our lives and transforming how we interact with services. Take, for instance, the immensely popular app Foursquare, where users who frequent a particular place and “check in” often receive discounts. Another example is Uber, which helps you secure a ride from your smartphone at a lower price than a traditional taxi. The list of such apps is vast and continues to expand.

location services API

In this article, we will create a basic Android application to determine the user’s latitude and longitude using Android’s Google Location Services API. When building Android applications, there are a couple of approaches to obtaining the user’s location.

Package “android.location”

The package “android.location” has been accessible since the inception of Android and grants access to location services. These services enable applications to acquire periodic updates on the device’s geographical position.

The package provides two methods for acquiring location data:

  • LocationManager.GPS_PROVIDER: This method pinpoints location using satellites. Depending on the circumstances, it might take a while to provide a location fix.

  • LocationManager.NETWORK_PROVIDER: This method determines location based on the accessibility of nearby cell towers and WiFi access points. It’s quicker than GPS_PROVIDER.

When determining user location, you must work with these providers and their availability. Ideally, you’d first obtain the location using NETWORK_PROVIDER, which, though potentially less accurate, is much faster. Subsequently, you could strive for greater accuracy by seeking a more precise location fix using the GPS_PROVIDER.

The APIs within this package are quite low-level, requiring developers to manage the intricacies of determining when to request location data and schedule calls to the API optimally. To enhance the developer experience with location-based system services and simplify the development of location-aware applications, Google introduced a new method for requesting a user’s location using Google Play Services. This method offers a more straightforward API with improved accuracy, low-power geofencing, and many other features.

Google Location Services API

Google Location Services API, also referred to as FusedLocationProviderApi, is Google’s recommended method for acquiring a user’s location. It provides optimal accuracy tailored to our requirements. Here are some advantages of using this API over the previous one:

  • Simplicity: Unlike the previous API, you no longer need to manage multiple providers. You simply specify high-level requirements like “high accuracy” or “low power,” and the API will choose a suitable approach.

  • Availability: It grants your app immediate access to the best, most up-to-date known location. This information is usually readily available; you just need to request it.

  • Power-efficiency: It minimizes your application’s power consumption.

  • Versatility: It caters to a wide range of needs, from foreground uses requiring highly accurate location data to background uses needing only periodic location updates with minimal power impact.

Let’s develop a location-based Android application using this API. We’ll use Google’s recommended IDE for Android application development - Android Studio. Getting started with Android Studio is fairly straightforward. Their website comprehensively details the installation and configuration of Android Studio, including how to set up your first Android application for development.

Android Studio should make things incredibly easy for us. However, we’ll need to start by configuring the build script and adding Google Play Services as a dependency for this application. We can do this by modifying the “build.gradle” file as follows:

1
2
3
4

dependencies {
    compile 'com.android.support:appcompat-v7:21.0.3'
    compile 'com.google.android.gms:play-services:6.5.87' // Add this line
}

As of this writing, the latest available version of Google Play Services is 6.5.87. Always check for the most recent version before starting. If newer versions are released later, and you choose to update your projects, test all location-related features against all Android versions you support.

At this point, we’re ready to begin the actual work on our application.

Requesting Permission, Configuring AndroidManifest.xml

Android devices have specific security features that prevent any random application from requesting a user’s precise location. To address this, we need to edit “AndroidManifest.xml” and add the permission we require for this application:

1

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />

While we’re at it, let’s also define the version of Google Play Services used in this application:

1
2

<meta-data android:name="com.google.android.gms.version"
           android:value="@integer/google_play_services_version" />

Checking for Google Play Services Availability

Before using features provided by Google Play Services, we must verify if the device has Google Play Services installed and if the version matches the one we intend to use (6.5.87).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

private boolean checkGooglePlayServices(){
	int checkGooglePlayServices = GooglePlayServicesUtil
		.isGooglePlayServicesAvailable(mContext);
	if (checkGooglePlayServices != ConnectionResult.SUCCESS) {
		/*
		* Google Play Services is missing or update is required
		*  return code could be
		* SUCCESS,
		* SERVICE_MISSING, SERVICE_VERSION_UPDATE_REQUIRED,
		* SERVICE_DISABLED, SERVICE_INVALID.
		*/
		GooglePlayServicesUtil.getErrorDialog(checkGooglePlayServices,
		mContext, REQUEST_CODE_RECOVER_PLAY_SERVICES).show();

		return false;
	}

	return true;
}

This method checks for Google Play Services. If the device doesn’t have it installed (rare, but it happens), it will display a dialog with the corresponding error and prompt the user to install/update Google Play Services from the Google Play Store.

Google play services

After the user addresses the resolution provided by “GooglePlayServicesUtil.getErrorDialog()”, a callback method “onActivityResult()” is triggered. So, we need to implement some logic to handle that call:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
	if (requestCode == REQUEST_CODE_RECOVER_PLAY_SERVICES) {
		if (resultCode == RESULT_OK) {
			// Make sure the app is not already connected or attempting to connect
			if (!mGoogleApiClient.isConnecting() &&
					!mGoogleApiClient.isConnected()) {
				mGoogleApiClient.connect();
			}
		} else if (resultCode == RESULT_CANCELED) {
			Toast.makeText(mContext, "Google Play Services must be installed.",
			Toast.LENGTH_SHORT).show();
			finish();
		}
	}
}

Accessing Google APIs

To access Google APIs, we only need to perform one more step: create an instance of GoogleApiClient. The Google API Client serves as a common entry point for all Google Play services and manages the network connection between the user’s device and each Google service. Our first step is to initiate the connection. I usually call this code from the “onCreate” method of the activity:

1
2
3
4
5
6
7

protected synchronized void buildGoogleApiClient() {
	mGoogleApiClient = new GoogleApiClient.Builder(this)
		.addConnectionCallbacks(this)
		.addOnConnectionFailedListener(this)
		.addApi(LocationServices.API)
		.build();
}

By chaining a series of method calls, we specify the callback interface implementation and the Location Service API we want to use. The interface implementation, in this case, “this,” will receive a response to the asynchronous “connect()” method when the connection to Google Play Services succeeds, fails, or is suspended. After adding this code, our “MainActivity” should look like this:

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

package com.bitwoo.userlocation;

import android.content.Intent;
import android.location.Location;
import android.os.Bundle;
import android.support.v7.app.ActionBarActivity;
import android.view.Menu;
import android.view.MenuItem;
import android.widget.Toast;

import com.google.android.gms.common.ConnectionResult;
import com.google.android.gms.common.GooglePlayServicesUtil;
import com.google.android.gms.common.api.GoogleApiClient;
import com.google.android.gms.location.LocationServices;


public class MainActivity extends ActionBarActivity  implements GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener {

	private static int REQUEST_CODE_RECOVER_PLAY_SERVICES = 200;

	private GoogleApiClient mGoogleApiClient;
	private Location mLastLocation;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);

		if (checkGooglePlayServices()) {
		buildGoogleApiClient();
		}
	}


	@Override
	public boolean onCreateOptionsMenu(Menu menu) {
		// Inflate the menu; this adds items to the action bar if it is present.
		getMenuInflater().inflate(R.menu.menu_main, menu);
		return true;
	}

	@Override
	public boolean onOptionsItemSelected(MenuItem item) {
		// Handle action bar item clicks here. The action bar will
		// automatically handle clicks on the Home/Up button, so long
		// as you specify a parent activity in AndroidManifest.xml.
		int id = item.getItemId();

		//noinspection SimplifiableIfStatement
		if (id == R.id.action_settings) {
		return true;
		}

		return super.onOptionsItemSelected(item);
	}

	private boolean checkGooglePlayServices() {

		int checkGooglePlayServices = GooglePlayServicesUtil
			.isGooglePlayServicesAvailable(this);
		if (checkGooglePlayServices != ConnectionResult.SUCCESS) {
			/*
			* google play services is missing or update is required
			*  return code could be
			* SUCCESS,
			* SERVICE_MISSING, SERVICE_VERSION_UPDATE_REQUIRED,
			* SERVICE_DISABLED, SERVICE_INVALID.
			*/
			GooglePlayServicesUtil.getErrorDialog(checkGooglePlayServices,
			this, REQUEST_CODE_RECOVER_PLAY_SERVICES).show();

			return false;
		}

		return true;

	}

	@Override
	protected void onActivityResult(int requestCode, int resultCode, Intent data) {
		if (requestCode == REQUEST_CODE_RECOVER_PLAY_SERVICES) {

			if (resultCode == RESULT_OK) {
				// Make sure the app is not already connected or attempting to connect
				if (!mGoogleApiClient.isConnecting() &&
					!mGoogleApiClient.isConnected()) {
					mGoogleApiClient.connect();
				}
			} else if (resultCode == RESULT_CANCELED) {
				Toast.makeText(this, "Google Play Services must be installed.",
				Toast.LENGTH_SHORT).show();
				finish();
			}
		}
	}

	protected synchronized void buildGoogleApiClient() {
		mGoogleApiClient = new GoogleApiClient.Builder(this)
			.addConnectionCallbacks(this)
			.addOnConnectionFailedListener(this)
			.addApi(LocationServices.API)
			.build();

	}


	@Override
	public void onConnected(Bundle bundle) {

	}

	@Override
	public void onConnectionSuspended(int i) {

	}

	@Override
	public void onConnectionFailed(ConnectionResult connectionResult) {

	}
}

Then, in our “onStart” method, we call the “connect” method and wait for the “onConnected” callback method to be invoked:

1
2
3
4
5
6
7
8

@Override
protected void onStart() {
	super.onStart();
	if (mGoogleApiClient != null) {
		mGoogleApiClient.connect();
	}

}

The “onConnected” method will look like this:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

@Override
public void onConnected(Bundle bundle) {

	mLastLocation = LocationServices.FusedLocationApi.getLastLocation(
		mGoogleApiClient);
	if (mLastLocation != null) {

		Toast.makeText(this, "Latitude:" + mLastLocation.getLatitude()+", Longitude:"+mLastLocation.getLongitude(),Toast.LENGTH_LONG).show();

	}

}

This callback is triggered when Google Play Services is connected, implying that we should have the last known location. However, this location could be null (rare, but possible). In such a case, I recommend listening for location updates, which we’ll cover next.

Listening for Location Updates

After calling “getLastLocation,” you might want to request periodic updates from the Fused Location Provider. This period could be short or long, depending on your application. For example, if you’re building an application that tracks a user’s location while driving, you’ll need to listen for updates at short intervals. Conversely, if your application involves sharing the user’s location with a friend, you might only need to request the location occasionally.

Creating a request is quite easy - you can call this method inside the “onCreate” method:

1
2
3
4
5
6

protected void createLocationRequest() {
	mLocationRequest = new LocationRequest();
	mLocationRequest.setInterval(20000);
	mLocationRequest.setFastestInterval(5000);
	mLocationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);
}

We create a new LocationRequest object. The interval is set to 20 seconds (20000 milliseconds). Additionally, we set a throttled update rate to 5 seconds. This instructs the API to provide updates every 20 seconds (ideally), but if a change occurs within a 5-second window, it should provide that as well. Finally, we set the priority to “PRIORITY_HIGH_ACCURACY” among other available priority options: PRIORITY_BALANCED_POWER_ACCURACY, PRIORITY_LOW_POWER, and PRIORITY_NO_POWER.

Once you’ve built the request, you’re ready to start listening for location updates after the “onConnected()” method is fired:

1
2
3
4

protected void startLocationUpdates() {
	LocationServices.FusedLocationApi.requestLocationUpdates(
		mGoogleApiClient, mLocationRequest, this);
}

Now, all that’s left is to implement the callback method to satisfy the LocationListener interface:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public class MainActivity extends ActionBarActivity implements
		ConnectionCallbacks, OnConnectionFailedListener, LocationListener {

	// ...

	@Override
	public void onLocationChanged(Location location) {
		mLastLocation = location;	
Toast.makeText(this, "Latitude:" + mLastLocation.getLatitude()+", Longitude:"+mLastLocation.getLongitude(),Toast.LENGTH_LONG).show();

	}

}
stop listening for updates

Stop Listening for Updates

It’s crucial to explicitly stop listening for updates when they’re no longer needed or if the user exits your application. The following method should be invoked from within the “onPause” callback:

1
2
3
4
5
6

protected void stopLocationUpdates() {
	if (mGoogleApiClient != null) {
		LocationServices.FusedLocationApi.removeLocationUpdates(
		mGoogleApiClient, this);
	}
}

… and disconnecting from the Google API:

1
2
3
4
5
6
7

@Override
protected void onStop() {
	super.onStop();
	if (mGoogleApiClient != null) {
		mGoogleApiClient.disconnect();
	}
}

Wrapping Up

As demonstrated, the core concepts behind implementing location-aware applications in Android are quite straightforward. Furthermore, with the available APIs being both user-friendly and easy to grasp, building basic location-based applications for Android should be a breeze. The small sample application we’ve built here serves to illustrate precisely that. You can find the complete source code for this on GitHub. Please note that for simplicity, the application doesn’t handle the “onConnectionFailed” callback method.

Hopefully, this tutorial will help you get started with the Google Location Services API.

Licensed under CC BY-NC-SA 4.0