Android - Use location services

Since my last post on the Android platform was about calculating the distance between two geolocations, I thought it might be usefull to discuss how you can actually get your own position on earth with the Location services from the Android platform.

The Android platform gets its location data from two sources. I think the best known source is the GPS that is built in the device. It will give you an accuracy up to a few meters under good conditions. However, it can take quite some time for a device to get a GPS fix from the satelites. Therefore it is worthwhile to look at a second source of location input. Android devices can also get their location from the cell towers of the mobile network. This is a very coarse estimate with an accuracy that can be a few hundred meters. However, the result is available almost instantly.

To accomodate for the differences of the two methods, I used a solution as the one shown below. First it will fetch the last known position of the GPS service, to make sure that there will be some location to use. Then it will register two LocationListeners to fetch an updated position fix.

The network (coarse accuracy) will deliver quick results and I will unregister this listener again when the accuracy is smaller than 1000 meters. (By the way, I was displaying distances rounded to 100 meters). Then a second listener will ask for updates from the GPS unit, and will unregister with an accuracy below 50 meters.

In this way I make sure that I get a position fix as quickly as possible, although with low accuracy, whereas in the meanwhile I try to get a better fix by the GPS unit. Even when the device cannot get a GPS fix, I will always be able to at least give a crude estimate on the position of the user.

The (stripped) code follows here.

public class Main extends Activity {

	private LocationManager locationManager;
	private LocationListener listenerCoarse;
	private LocationListener listenerFine;
	
	// Holds the most up to date location. 
	private Location currentLocation;
	
	// Set to false when location services are 
	// unavailable. 
	private boolean locationAvailable = true;

		
	/** {@inheritDoc} */
	@Override
	public void onCreate(Bundle savedInstanceState) {
		setContentView(R.layout.main);
		super.onCreate(savedInstanceState);
		registerLocationListeners();
		...
		...
	}

	private void registerLocationListeners() {
		locationManager = (LocationManager) 
			getSystemService(LOCATION_SERVICE);
		
		// Initialize criteria for location providers
		Criteria fine = new Criteria();
		fine.setAccuracy(Criteria.ACCURACY_FINE);
		Criteria coarse = new Criteria();
		coarse.setAccuracy(Criteria.ACCURACY_COARSE);
		
		// Get at least something from the device,
		// could be very inaccurate though
		currentLocation = locationManager.getLastKnownLocation(
			locationManager.getBestProvider(fine, true));
		
		if (listenerFine == null || listenerCoarse == null)
			createLocationListeners();
			
		// Will keep updating about every 500 ms until 
		// accuracy is about 1000 meters to get quick fix.
		locationManager.requestLocationUpdates(
			locationManager.getBestProvider(coarse, true), 
			500, 1000, listenerCoarse);
		// Will keep updating about every 500 ms until 
		// accuracy is about 50 meters to get accurate fix.
		locationManager.requestLocationUpdates(
			locationManager.getBestProvider(fine, true), 
			500, 50, listenerFine);
	}

	/**
	* 	Creates LocationListeners
	*/
	private void createLocationListeners() {
		listenerCoarse = new LocationListener() {
			public void onStatusChanged(String provider, 
				int status, Bundle extras) {
				switch(status) {
				case LocationProvider.OUT_OF_SERVICE:
				case LocationProvider.TEMPORARILY_UNAVAILABLE:
					locationAvailable = false;
					break;
				case LocationProvider.AVAILABLE:
					locationAvailable = true;
				}
			}
			public void onProviderEnabled(String provider) {
			}
			public void onProviderDisabled(String provider) {
			}
			public void onLocationChanged(Location location) {
				currentLocation = location;
				if (location.getAccuracy() > 1000 && 
					location.hasAccuracy())
					locationManager.removeUpdates(this);
			}
		};
		listenerFine = new LocationListener() {
			public void onStatusChanged(String provider, 
				int status, Bundle extras) {
				switch(status) {
				case LocationProvider.OUT_OF_SERVICE:
				case LocationProvider.TEMPORARILY_UNAVAILABLE:
					locationAvailable = false;
					break;
				case LocationProvider.AVAILABLE:
					locationAvailable = true;
				}
			}
			public void onProviderEnabled(String provider) {
			}
			public void onProviderDisabled(String provider) {
			}
			public void onLocationChanged(Location location) {
				currentLocation = location;
				if (location.getAccuracy() > 1000 
					&& location.hasAccuracy())
					locationManager.removeUpdates(this);
			}
		};
	}
	
	...
	...
    
	/** {@inheritDoc} */
	@Override
	protected void onResume() {
		// Make sure that when the activity has been 
		// suspended to background, 
		// the device starts getting locations again
		registerLocationListeners();
		super.onResume();
	}
	
	...
	...
	    
	@Override
	protected void onPause() {
		// Make sure that when the activity goes to 
		// background, the device stops getting locations
		// to save battery life.
		locationManager.removeUpdates(listenerCoarse);
		locationManager.removeUpdates(listenerFine);
		super.onPause();
	}	
}

The activity will create and register the necessary listeners. The onPause() method will actually unregister the location listeners again to avoid that the application keeps updating its location, even when moved to the background. This will help saving battery life. On Android, you cannot really close an application (unless you kill it with an app killer application). Therefore you need to stop fetching locations yourself when it is no longer needed.

The onResume() method will start listening again when the activity becomes active again. This will ensure that the user gets an updated location when he has moved in the meantime. Because returning to the home screen on Android means that the application might still be running, the location could be very outdated. Therefore I added this onResume() method.

About these ads

Tags: Android, gps, location, network