Google Maps is one of the many applications bundled with the Android
platform. In addition to simply using the Maps application, you can also
embed it into your own applications and make it do some very cool
things. In this article, I will show you how to use Google Maps in your
Android applications and how to programmatically perform the following:

Change the views of Google Maps

Obtain the latitude and longitude of locations in Google Maps

Perform geocoding and reverse geocoding

Add markers to Google Maps

Creating the Project

Using Eclipse, create a new Android project and name GoogleMaps as shown in Figure 1.

Figure 1 Creating a new Android project using Eclipse

Obtaining a Maps API key

Beginning with the Android SDK release v1.0, you need to apply for a
free Google Maps API key before you can integrate Google Maps into your
Android application. To apply for a key, you need to follow the series
of steps outlined below. You can also refer to Google's detailed
documentation on the process at http://code.google.com/android/toolbox/apis/mapkey.html.
First, if you are testing the application on the Android emulator,
locate the SDK debug certificate located in the default folder of "C:\Documents and Settings\\Local Settings\Application Data\Android". The filename of the debug keystore is debug.keystore. For deploying to a real Android device, substitute the debug.keystore file with your own keystore file. In a future article I will discuss how you can generate your own keystore file.
For simplicity, copy this file (debug.keystore) to a folder in C:\ (for example, create a folder called "C:\Android").
Using the debug keystore, you need to extract its MD5 fingerprint using the Keytool.exe
application included with your JDK installation. This fingerprint is
needed to apply for the free Google Maps key. You can usually find the Keytool.exe from the "C:\Program Files\Java\\bin" folder.
Issue the following command (see also Figure 2) to extract the MD5 fingerprint.

Displaying the Map

To display the Google Maps in your Android application, modify the main.xml file located in the res/layout folder. You shall use the element to display the Google Maps in your activity. In addition, let's use the element to position the map within the activity:

Notice from above that I have used the Google Maps key that I obtained earlier and put it into the apiKey attribute.
In the MapsActivity.java file, modify the class to extend from the MapActivity class, instead of the normal Activity class:

Observe that if your class extends the MapActivity class, you need to override the isRouteDisplayed() method. You can simply do so by setting the method to return false.
That's it! That's all you need to do to display the Google Maps in your application. Press F11 in Eclipse to deploy the application onto an Android emulator. Figure 3 shows the Google map in all its glory.

Figure 3 Google Maps in your application

At this juncture, take note of a few troubleshooting details. If your
program does not run (i.e. it crashes), then it is likely you forgot to
put the following statement in your AndroidManifest.xml file:

android:name="com.google.android.maps"/>

If your application manages to load but you cannot see the map (all
you see is a grid), then it is very likely you do not have a valid Map
key, or that you did not specify the INTERNET permission:

android:name="android.permission.INTERNET"/>

Displaying the Zoom View

The previous section showed how you can display the Google Maps in
your Android device. You can drag the map to any desired location and it
will be updated on the fly. However, observe that there is no way to
zoom in or out from a particular location. Thus, in this section, you
will learn how you can let users zoom into or out of the map.
First, add a element to the main.xml file as shown below:

Basically, you obtain the MapView instance on the activity, obtain its zoom controls and then add it to the LinearLayout
element you added to the activity earlier on. In the above case, the
zoom control will be displayed at the bottom of the screen. When you now
press F11 in Eclipse, you will see the zoom controls when you touch the map (see Figure 4).

Figure 4 Using the zoom controls in Google Maps

Using the zoom control, you can zoom in or out of a location by simply touching the "+ or "-" buttons on the screen.
Alternatively, you can also programmatically zoom in or out of the map using the zoomIn() and zoomOut() methods from the MapController class:

Displaying a Particular Location

Be default, the Google Maps displays the map of the United States
when it is first loaded. However, you can also set the Google Maps to
display a particular location. In this case, you can use the animateTo() method of the MapController class.
The following code shows how this is done:

In the above code, you first obtain a controller from the MapView instance and assign it to a MapController object (mc). You use a GeoPoint
object to represent a geographical location. Note that for this class
the latitude and longitude of a location are represented in micro
degrees. This means that they are stored as integer values. For a
latitude value of 40.747778, you need to multiply it by 1e6 to obtain
40747778.
To navigate the map to a particular location, you can use the animateTo() method of the MapController class (an instance which is obtained from the MapView object). The setZoom()
method allows you to specify the zoom level in which the map is
displayed. Figure 6 shows the Google Maps displaying the map of
Singapore.

Figure 6 Navigating to a particular location on the map

Adding Markers

Very often, you may wish to add markers to the map to indicate places
of interests. Let's see how you can do this in Android. First, create a
GIF image containing a pushpin (see Figure 7) and copy it into the res/drawable
folder of the project. For best effect, you should make the background
of the image transparent so that it does not block off parts of the map
when the image is added to the map.

Figure 7 Adding an image to the res/drawable folder

To add a marker to the map, you first need to define a class that extends the Overlay class:

In the MapOverlay class that you have defined, override the draw()
method so that you can draw the pushpin image on the map. In
particular, note that you need to translate the geographical location
(represented by a GeoPoint object, p) into screen coordinates.
As you want the pointed tip of the push pin to indicate the position
of the location, you would need to deduct the height of the image (which
is 50 pixels) from the y-coordinate of the point (see Figure 8) and
draw the image at that location.

Figure 8 Adding an image to the map

To add the marker, create an instance of the MapOverlap class and add it to the list of overlays available on the MapView object:

Getting the Location that was touched

After using Google Maps for a while, you may wish to know the
latitude and longitude of a location corresponding to the position on
the screen that you have just touched. Knowing this information is very
useful as you can find out the address of a location, a process known as
Geocoding (you will see how this is done in the next section).
If you have added an overlay to the map, you can override the onTouchEvent() method within the Overlay class. This method is fired every time the user touches the map. This method has two parameters - MotionEvent and MapView. Using the MotionEvent parameter, you can know if the user has lifted his finger from the screen using the getAction()
method. In the following code, if the user has touched and then lifted
his finger, you will display the latitude and longitude of the location
touched:

Figure 10 Displaying the latitude and longitude of a point touched on the map

Geocoding and Reverse Geocoding

If you know the latitude and longitude of a location, you can find
out its address using a process known as Geocoding. Google Maps in
Android supports this via the Geocoder class. The following code shows how you can find out the address of a location you have just touched using the getFromLocation() method:

If you know the address of a location but want to know its latitude
and longitude, you can do so via reverse-Geocoding. Again, you can use
the Geocoder class for this purpose. The following code shows how you can find the exact location of the Empire State Building by using the getFromLocationName() method:

Once the location is found, the above code navigates the map to the location. Figure 12 shows the code in action.

Figure 12 Navigating to the Empire State Building

Summary

In this article, you have learnt a few tricks for the Google Maps in
Android. Using Google Maps, there are many interesting projects you can
work on, such as geo-tagging, geo-tracking, etc. If you have cool ideas
on building cool location-based services, share with us in the comments
box below. Have fun!