Chapter 8

Locating and Sensing

The Android platform uses many different technologies. Some of them are new, and some have been seen before in other settings. What’s unique about Android is how these technologies work together. In this chapter, we’ll consider the following:

•Location awareness, through inexpensive GPS devices

•Handheld accelerometers, such as those found on the Nintendo Wii remote

•Mashups, often combining maps with other information

Several popular Android programs use these concepts to create a more compelling and relevant experience for the user. For example, the Locale application1 can adapt the settings on your phone based on where you are. Are you always forgetting to set your ringer to vibrate when you’re at work or the movies? Locale can take care of that using the Android Location API described here.

8.1Location, Location, Location

Right now there are thirty-one satellites zipping around the world with nothing better to do than help you find your way to the grocery store. The Global Positioning System (GPS), originally developed by the military but then converted to civilian use, beams highly precise time signals to Earth-based receivers such as the one in your Android phone. With good reception and a little math, the GPS chip can figure out your position to within 50 feet.2

1. http://www.androidlocale.com

2. You don’t have to know how GPS works to use it, but if you’re curious, see http://adventure.howstuffworks.com/gps.htm.

LOCATION, LOCATION, LOCATION 162

Joe Asks. . .

Does GPS Let Anyone Snoop on My Location?

No. GPS receivers are just that—receivers. The GPS chip, and thus any program running in your Android device, knows where it is. But unless one of those programs deliberately transmits that information, nobody can use it to find you.

In addition to GPS, Android also supports calculating your position using information from nearby cell phone towers, and if you’re connected to a wifi hotspot, it can use that too. Keep in mind that all these location providers are unreliable to some extent. When you walk inside a building, for example, GPS signals can’t reach you.

To demonstrate Android’s location services, let’s write a test program that simply displays your current position and keeps updating it on the screen as you move around. You can see the program in Figure 8.1, on the next page.

Where Am I?

Start by creating a “Hello, Android” application using these parameters in the New Project wizard:

Project name: LocationTest

Build Target: Android 2.2

Application name: LocationTest

Package name: org.example.locationtest

Create Activity: LocationTest

Min SDK Version: 8

Access to location information is protected by Android permissions. To gain access, you’ll need to add these lines in the AndroidManifest.xml file before the <application> tag:

Download LocationTest/AndroidManifest.xml

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

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

LOCATION, LOCATION, LOCATION 163

Figure 8.1: Testing the LocationManager

In this example, both fine-grained location providers such as GPS and coarse-grained location providers such as cell tower triangulation will be supported.

For the user interface, we’re going to print all the location data into a big scrolling TextView, which is defined in res/layout/main.xml:

Download LocationTest/res/layout/main.xml

<?xml version="1.0" encoding="utf-8"?>

<ScrollView xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent">

<TextView android:id="@+id/output"

android:layout_width="fill_parent" android:layout_height="wrap_content" />

</ScrollView>

LOCATION, LOCATION, LOCATION 165

On line 29, we call our dumpProviders( ) method to print a list of all the location providers in the system.

Next we need to pick one of the possible providers to use. I’ve seen some examples that simply pick the first available one, but I recommend using the getBestProvider( ) method, as shown here. Android will pick the best provider according to a Criteria that you provide (see line 31). If you have any restrictions on cost, power, accuracy, and so on, this is where you put them. In this example, there are no restrictions.

Depending on the provider, it may take some time for the device to figure out your current location. This could be a few seconds, a minute, or more. However, Android remembers the last position it returned, so we can query and print that immediately on line 36. This location could be out of date—for example, if the device was turned off and moved— but it’s usually better than nothing.

Knowing where we were is only half the fun. Where are we going next?

Updating the Location

To have Android notify you about location changes, call the requestLocationUpdates( ) method on the LocationManager object. To save battery power, we want updates only when the program is in the foreground. Therefore, we need to hook into the Android activity life-cycle methods by overriding onResume( ) and onPause( ):

Download LocationTest/src/org/example/locationtest/LocationTest.java

@Override

protected void onResume() { super.onResume();

// Start updates (doc recommends delay >= 60000 ms) mgr.requestLocationUpdates(best, 15000, 1, this);

}

@Override

protected void onPause() { super.onPause();

// Stop updates to save power while app paused mgr.removeUpdates(this);

}

When the application resumes, we call requestLocationUpdates( ) to start the update process. It takes four parameters: the provider name, a delay (so you don’t get updates too often), a minimum distance (changes less than this are ignored), and a LocationListener object.

LOCATION, LOCATION, LOCATION 166

When the application pauses, we call removeUpdates( ) to stop getting updates. The location provider will be powered down if it’s not needed for a while.

Now you know why LocationTest implements LocationListener, so we could just pass a reference to the activity instead of making a new listener object. That will save us about 1KB of memory at runtime.

Here’s the definition of the four methods required by that interface:

Download LocationTest/src/org/example/locationtest/LocationTest.java

public void onLocationChanged(Location location) { dumpLocation(location);

}

public void onProviderDisabled(String provider) { log("\nProvider disabled: " + provider);

}

public void onProviderEnabled(String provider) { log("\nProvider enabled: " + provider);

}

public void onStatusChanged(String provider, int status, Bundle extras) {

log("\nProvider status changed: " + provider + ", status="

+ S[status] + ", extras=" + extras);

}

The most important method in the bunch is onLocationChanged( ).

As the name suggests, it’s called every time the provider notices that the device’s location has changed. The onProviderDisabled( ), onProviderEnabled( ), and onStatusChanged( ) methods can be used to switch to other providers in case your first choice becomes unavailable.

The code for the remaining methods of LocationTest—log( ), dumpProviders( ), and dumpLocation( )—is not very interesting, but here it is for completeness:

Download LocationTest/src/org/example/locationtest/LocationTest.java

// Define human readable names

private static final String[] A = { "invalid", "n/a", "fine", "coarse" }; private static final String[] P = { "invalid", "n/a", "low", "medium",

"high" };

private static final String[] S = { "out of service",

"temporarily unavailable", "available" };

LOCATION, LOCATION, LOCATION 167

/** Write a string to the output window */ private void log(String string) {

output.append(string + "\n");

}

/** Write information from all location providers */ private void dumpProviders() {

List<String> providers = mgr.getAllProviders(); for (String provider : providers) {

dumpProvider(provider);

}

}

/** Write information from a single location provider */ private void dumpProvider(String provider) {

LocationProvider info = mgr.getProvider(provider); StringBuilder builder = new StringBuilder(); builder.append("LocationProvider[")

.append("name=")

.append(info.getName())

.append(",enabled=")

.append(mgr.isProviderEnabled(provider))

.append(",getAccuracy=")

.append(A[info.getAccuracy() + 1])

.append(",getPowerRequirement=")

.append(P[info.getPowerRequirement() + 1])

.append(",hasMonetaryCost=")

.append(info.hasMonetaryCost())

.append(",requiresCell=")

.append(info.requiresCell())

.append(",requiresNetwork=")

.append(info.requiresNetwork())

.append(",requiresSatellite=")

.append(info.requiresSatellite())

.append(",supportsAltitude=")

.append(info.supportsAltitude())

.append(",supportsBearing=")

.append(info.supportsBearing())

.append(",supportsSpeed=")

.append(info.supportsSpeed())

.append("]"); log(builder.toString());

}

/** Describe the given location, which might be null */ private void dumpLocation(Location location) {

if (location == null) log("\nLocation[unknown]");

else

log("\n" + location.toString());

}