Unlimited Plugins, WordPress themes, videos & courses! Unlimited asset downloads! From $16.50/m
  1. Code
  2. Android SDK

Android SDK: Working with Google Maps - Google Places Integration

Read Time:8 minsLanguages:

Google Maps provides Android developers with localization tools that can be included within your own app interfaces. In this series, we are creating a basic Android application with Google Maps and Google Places integration. In this part, we will access the Google Places API to retrieve information about places of interest near the user's current location. We will use the returned data to present markers for each place on the map in the final part of this tutorial series. We will also set the application to update the map markers when the user's location changes.

This is the third of four parts in a tutorial series on Using Google Maps and Google Places in Android apps:

App We Are Working TowardsApp We Are Working TowardsApp We Are Working Towards
This is a snapshot of the final app.

1. Get Google Places API Access

Step 1

In the first part of this series we used the Google API Console to get an API key for the mapping tools. Now we need to do the same for the Google Places API. Sign into your Google Account and browse to the Console again. Select Services from the options in the left-hand column and scroll down to the entry for Places API. Click to turn Places on for your account.

Places API OnPlaces API OnPlaces API On

Remember you need to carry out this step for any Google API service you wish to access, as your keys will not work otherwise.

Step 2

Now we need to get the key to access the Places API. Select API Access from the left-hand column in your Google APIs Console. You will see the page we used in the first part of the series to retrieve an API key for the mapping package. Although we are going to use the Places API in an Android app, the type of access is actually the same as for browser apps. When we retrieve the Places data, we request it using a URL and retrieve the results in JSON format, as you would in a Web application. Copy the key listed in the Key for browser apps section and save it.

Places API KeyPlaces API KeyPlaces API Key

We're finished with the Google APIs Console so feel free to log out of your account.

2. Build a Places Search Query

Step 1

Google Places API provides a range of information about places. For our app, we are going to use the Place Search request to return a list of places near the user's current location. We need to build the necessary elements into a URL query string to execute the Place Search. This is the basic format of the URL:

The output can be JSON or XML; we will use JSON for this app. The URL must be appended with various required parameters, including your API key, the user's location as longitude and latitude values, the radius to search within, and a boolean flag indicating whether the location was derived from a location sensor such as a GPS. There are various optional parameters you can add to your query; see the Place Search documentation for an overview. For the purpose of this app, we will add the optional types parameter to search for places of particular types.

This is an indicator of what the final query will look like:

We will build the longitude and latitude values dynamically (the hard-coded example values above are just for demonstration). The radius value is in meters, so feel free to alter it to suit the purpose of your app. You can also alter the place types if you wish; see the Supported Place Types overview for the available options. Make sure you separate the place types using the pipe "|" character. You should of course alter the key parameter value to reflect your own API key.

In your Activity class updatePlaces helper method, after the existing code in which we retrieved the user location and animated the map camera to it, create a string for the Place Search URL:

Include the API key you copied from the Google APIs Console for browser apps. Note that we pass the latitude and longitude values we previously retrieved from the user's location.

3. Create an AsyncTask to Fetch Place Data in the Background

Step 1

You will need to add the following import statements to your Activity class for the code we'll use next:

Since we will fetch data over the Web, we will use an AsyncTask to carry out this process off the UI thread. This will allow us to handle the results within the UI thread, adding markers to the visible map when the app receives the Place Search data.

In your Activity class, create the AsyncTask class outline as follows:

The three types indicated represent the types of parameters, progress units, and the result of the background operation. We will pass the Place Search URL as a string, so this is the parameter. We won't indicate progress for this app, so the second type is void. The result of the background operation in this case will be a JSON string representing the places, so the third type is a text string.

Step 2

When you use an AsyncTask, you indicate the processing you want to occur in the background within the doInBackground method. Once that has executed and retrieved a result, the onPostExecute method will then execute. For this app, we will fetch the Place Search results in doInBackground, then parse the results in onPostExecute, creating markers to display on the map at the same time.

Inside your AsyncTask class, add the doInBackground method:

The parameter type is string, as indicated by the class outline above. Let's use a String Builder to build the returned JSON text string inside this new method:

Although we will only pass a single Place Search query URL string, the doInBackground method expects to potentially receive an array of parameters, so add a loop to process this:

Inside the loop, create an HTTP Client object to execute the query URL:

As with any input/output process, we need to take care of potential errors, so add try and catch blocks next, still inside the loop:

Inside the try block, create an HTTP Get object, passing the URL string:

Use the HTTP Client to execute this, retrieving an HTTP Response:

Let's check that we have a positive response before we attempt to carry out any further processing. Retrieve the status line:

We can only continue if we have a 200 "OK" status code indicating that the request was successful, so add a conditional statement:

Inside the if block, retrieve the HTTP Entity from the response object:

Now we can start to retrieve the actual content of the response, which should be the JSON string. Start by creating an Input Stream:

Now create a reader for this stream:

Let's carry out our input stream processing using a Buffered Reader:

Now we can use a loop to read the input one line at a time, appending each one to the String Builder as we go along:

This loop will continue to execute as long as there is still data to read in.

Finally, we can return the string that is handled by the String Builder. At the end of the doInBackground method after the for loop, return the JSON data:


The third part of this tutorial series is now complete. We set the app up to utilize Google Places API and created an inner class to fetch the place data in the background off the app's main UI thread. We executed the Place Search query and retrieved the resulting JSON. When you run your app, it will not behave any differently than it did after the previous part of this series. This is because we have not yet completed or instantiated the AsyncTask class. We will do that in the final part, after we add the onPostExecute method to parse the JSON Place Search result and translate it into map markers. We will also extend the app to update the displayed markers as the user's location changes.

Looking for something to help kick start your next project?
Envato Market has a range of items for sale to help get you started.