Developing Sensor Applications on Intel Atom Processor-Based Android Phones and Tablets

This guide provides application developers with an introduction to the Android Sensor framework and discusses how to use some of the sensors that are generally available on phones and tablets based on the Intel Atom processor.

Developing Sensor Applications on Intel® Atom™ Processor-Based Android* Phones and Tablets

---

This guide provides application developers with an introduction to the Android Sensor framework and discusses how to use some of the sensors that are generally available on phones and tablets based on the Intel® Atom™ processor. Among those discussed are the motion, position, and environment sensors. Even though GPS is not strictly categorized as a sensor in the Android framework, this guide discusses GPS-based location services as well. The discussion in this guide is based on Android 4.2, Jelly Bean.

Sensors on Intel® Atom™ Processor-Based Android Phones and Tablets

---

The Android phones and tablets based on Intel Atom processors can support a wide range of hardware sensors. These sensors are used to detect motion and position changes, and report the ambient environment parameters. The block diagram in Figure 1 shows a possible sensor configuration on a typical Intel Atom processor-based Android device.

Figure 1. Sensors on an Intel® Atom™–based Android system

Based on the data they report, we can categorize Android sensors into the classes and types shown in Table 1.

Motion Sensors	Accelerometer (TYPE_ACCELEROMETER)	Measures a device’s accelerations in m/s2	Motion detection
	Gyroscope (TYPE_GYROSCOPE)	Measures a device’s rates of rotation	Rotation detection
Position Sensors	Magnetometer (TYPE_MAGNETIC_FIELD)	Measures the Earth’s geomagnetic field strengths in µT	Compass
	Proximity (TYPE_PROXIMITY)	Measures the proximity of an object in cm	Nearby object detection
	GPS (not a type of android.hardware.Sensor)	Gets accurate geo-locations of the device	Accurate geo-location detection
Environment Sensors	ALS (TYPE_LIGHT)	Measures the ambient light level in lx	Automatic screen brightness control
	Barometer	Measures the ambient air pressure in mbar	Altitude detection

Table 1. Sensor Types Supported by the Android Platform

Android Sensor Framework

---

The Android sensor framework provides mechanisms to access the sensors and sensor data, with the exception of the GPS, which is accessed through the Android location services. We will discuss this later in this paper. The sensor framework is part of the android.hardware package. Table 2 lists the main classes and interfaces of the sensor framework.

Name	Type	Description
SensorManager	Class	Used to create an instance of the sensor service. Provides various methods for accessing sensors, registering and unregistering sensor event listeners, and so on.
Sensor	Class	Used to create an instance of a specific sensor.
SensorEvent	Class	Used by the system to publish sensor data. It includes the raw sensor data values, the sensor type, the data accuracy, and a timestamp.
SensorEventListener	Interface	Provides callback methods to receive notifications from the SensorManager when the sensor data or the sensor accuracy has changed.

Table 2. The Android Platform Sensor Framework

Obtaining Sensor Configuration

Device manufacturers decide what sensors are available on the device. You must discover which sensors are available at runtime by invoking the sensor framework’s SensorManager getSensorList() method with a parameter “Sensor.TYPE_ALL”. Code Example 1 displays a list of available sensors and the vendor, power, and accuracy information of each sensor.

 

001	package com.intel.deviceinfo;

002

003	import java.util.ArrayList;

004	import java.util.HashMap;

005	import java.util.List;

006	import java.util.Map;

007

008	import android.app.Fragment;

009	import android.content.Context;

010	import android.hardware.Sensor;

011	import android.hardware.SensorManager;

012	import android.os.Bundle;

013	import android.view.LayoutInflater;

014	import android.view.View;

015	import android.view.ViewGroup;

016	import android.widget.AdapterView;

017	import android.widget.AdapterView.OnItemClickListener;

018	import android.widget.ListView;

019	import android.widget.SimpleAdapter;

020

021	public class SensorInfoFragment extends Fragment {

022

023	private View mContentView;

024

025	private ListView mSensorInfoList;

026	SimpleAdapter mSensorInfoListAdapter;

027

028	private List<Sensor> mSensorList;

029

030	private SensorManager mSensorManager;

031

032

@Override

033	public void onActivityCreated(Bundle savedInstanceState) {

034	super.onActivityCreated(savedInstanceState);

035

}

036

037

@Override

038	public void onPause()

039

{

040	super.onPause();

041

}

042

043

@Override

044	public void onResume()

045

{

046	super.onResume();

047

}

048

049

@Override

050	public View onCreateView(LayoutInflater inflater, ViewGroup container,

051	Bundle savedInstanceState) {

052	mContentView = inflater.inflate(R.layout.content_sensorinfo_main, null);

053	mContentView.setDrawingCacheEnabled(false);

054

055	mSensorManager = (SensorManager)getActivity().getSystemService(Context.SENSOR_SERVICE);

056

057	mSensorInfoList = (ListView)mContentView.findViewById(R.id.listSensorInfo);

058

059	mSensorInfoList.setOnItemClickListener( new OnItemClickListener() {

060

061

@Override

062	public void onItemClick(AdapterView<?> arg0, View view, int index,long arg3) {

063

064	// with the index, figure out what sensor was pressed

065	Sensor sensor = mSensorList.get(index);

066

067	// pass the sensor to the dialog.

068	SensorDialog dialog = new SensorDialog(getActivity(), sensor);

069

070	dialog.setContentView(R.layout.sensor_display);

071	dialog.setTitle("Sensor Data");

072	dialog.show();

073

}

074

});

075

076	return mContentView;

077

}

078

079	void updateContent(int category, int position) {

080	mSensorInfoListAdapter = new SimpleAdapter(getActivity(),

081	getData() , android.R.layout.simple_list_item_2,

082	new String[] {

083

"NAME",

084

"VALUE"

085

},

086	new int[] { android.R.id.text1, android.R.id.text2 });

087	mSensorInfoList.setAdapter(mSensorInfoListAdapter);

088

}

089

090

091	protected void addItem(List<Map<String, String>> data, String name, String value)   {

092	Map<String, String> temp = new HashMap<String, String>();

093	temp.put("NAME", name);

094	temp.put("VALUE", value);

095	data.add(temp);

096

}

097

098

099	private List<? extends Map<String, ?>> getData() {

100	List<Map<String, String>> myData = new ArrayList<Map<String, String>>();

101	mSensorList = mSensorManager.getSensorList(Sensor.TYPE_ALL);

102

103	for (Sensor sensor : mSensorList ) {

104	addItem(myData, sensor.getName(),  "Vendor: " + sensor.getVendor() +", min. delay: " + sensor.getMinDelay() +", power while in use: " + sensor.getPower() + "mA, maximum range: " + sensor.getMaximumRange() + ", resolution: " + sensor.getResolution());

105

}

106	return myData;

107

}

108

}

Code Example 1. A Fragment that Displays the List of Sensors**

Sensor Coordinate System

The sensor framework reports sensor data using a standard 3-axis coordinate system, where X, Y, and Z are represented by values[0], values[1], and values[2] in the SensorEvent object, respectively.

Some sensors, such as light, temperature, proximity, and pressure, return only single values. For these sensors only values[0] in the SensorEvent object are used.

Other sensors report data in the standard 3-axis sensor coordinate system. The following is a list of such sensors:

• Accelerometer
• Gravity sensor
• Gyroscope
• Geomagnetic field sensor

The 3-axis sensor coordinate system is defined relative to the screen of the device in its natural (default) orientation. For a phone, the default orientation is portrait; for a tablet, the natural orientation is landscape. When a device is held in its natural orientation, the x axis is horizontal and points to the right, the y axis is vertical and points up, and the z axis points outside of the screen (front) face. Figure 2 shows the sensor coordinate system for a phone, and Figure 3 for a tablet.

Figure 2. The sensor coordinate system for a phone

Figure 3. The sensor coordinate system for a tablet

The most important point regarding the sensor coordinate system is that the sensor’s coordinate system never changes when the device moves or changes its orientation.

Monitoring Sensor Events

The sensor framework reports sensor data with the SensorEvent objects. A class can monitor a specific sensor’s data by implementing the SensorEventListener interface and registering with the SensorManager for the specific sensor. The sensor framework informs the class about the changes in the sensor states through the following two SensorEventListener callback methods implemented by the class:

 

onAccuracyChanged()

and

 

onSensorChanged()

Code Example 2 implements the SensorDialog used in the SensorInfoFragment example we discussed in the section “Obtaining Sensor Configuration.”

01	package com.intel.deviceinfo;

02

03	import android.app.Dialog;

04	import android.content.Context;

05	import android.hardware.Sensor;

06	import android.hardware.SensorEvent;

07	import android.hardware.SensorEventListener;

08	import android.hardware.SensorManager;

09	import android.os.Bundle;

10	import android.widget.TextView;

11

12	public class SensorDialog extends Dialog implements SensorEventListener {

13	Sensor mSensor;

14	TextView mDataTxt;

15	private SensorManager mSensorManager;

16

17	public SensorDialog(Context ctx, Sensor sensor) {

18	this(ctx);

19	mSensor = sensor;

20

}

21

22

@Override

23	protected void onCreate(Bundle savedInstanceState) {

24	super.onCreate(savedInstanceState);

25	mDataTxt = (TextView) findViewById(R.id.sensorDataTxt);

26	mDataTxt.setText("...");

27	setTitle(mSensor.getName());

28

}

29

30

@Override

31	protected void onStart() {

32	super.onStart();

33	mSensorManager.registerListener(this, mSensor,  SensorManager.SENSOR_DELAY_FASTEST);

34

}

35

36

@Override

37	protected void onStop() {

38	super.onStop();

39	mSensorManager.unregisterListener(this, mSensor);

40

}

41

42

@Override

43	public void onAccuracyChanged(Sensor sensor, int accuracy) {

44

}

45

46

@Override

47	public void onSensorChanged(SensorEvent event) {

48	if (event.sensor.getType() != mSensor.getType()) {

49

return;

50

}

51	StringBuilder dataStrBuilder = new StringBuilder();

52	if ((event.sensor.getType() == Sensor.TYPE_LIGHT)||

53	(event.sensor.getType() == Sensor.TYPE_TEMPERATURE)||

54	(event.sensor.getType() == Sensor.TYPE_PRESSURE)) {

55	dataStrBuilder.append(String.format("Data: %.3fn", event.values[0]));

56

}

57

else{

58	dataStrBuilder.append(

59	String.format("Data: %.3f, %.3f, %.3fn",

60	event.values[0], event.values[1], event.values[2] ));

61

}

62	mDataTxt.setText(dataStrBuilder.toString());

63

}

64

}

Code Example 2. A Dialog that Shows the Sensor Values**

 

Motion Sensors

Motion sensors are used to monitor device movement, such as shake, rotate, swing, or tilt. The accelerometer and gyroscope are two motion sensors available on many tablet and phone devices.

Motion sensors report data using the sensor coordinate system, where the three values in the SensorEvent object, values[0], values[1], and values[2], represent the x-, y-, and z-axis values, respectively.

To understand the motion sensors and apply the data in an application, we need to apply some physics formulas related to force, mass, acceleration, Newton’s laws of motion, and the relationship between several of these entities in time. To learn more about these formulas and relationships, refer to your favorite physics textbooks or public domain sources.

 

Accelerometer

The accelerometer measures the acceleration applied on the device, and its properties are summarized in Table 3.

Sensor	Type	SensorEvent Data (m/s2)	Description
Accelerometer	TYPE_ACCELEROMETER	values[0] values[1] values[2]	Acceleration along the x axis Acceleration along the y axis Acceleration along the z axis

Table 3. The Accelerometer

The concept for the accelerometer is derived from Newton’s second law of motion:

a = F/m

The acceleration of an object is the result of the net external force applied to the object. The external forces include one that applies to all objects on Earth, gravity. It is proportional to the net force F applied to the object and inversely proportional to the object’s mass m.

In our code, instead of directly using the above equation, we are more concerned about the result of the acceleration during a period of time on the device’s speed and position. The following equation describes the relationship of an object’s velocity v1, its original velocity v0, the acceleration a, and the time t:

v1 = v0 + at

To calculate the object’s position displacement s, we use the following equation: s = v0t + (1/2)at2

In many cases we start with the condition v0 equal to 0 (before the device starts moving), which simplifies the equation to: s = at2/2

Because of gravity, the gravitational acceleration, represented with the symbol g, is applied to all objects on Earth. Regardless of the object’s mass, gonly depends on the latitude of the object’s location with a value in the range of 9.78 to 9.82 (m/s^{2). We adopt a conventional standard value for g:} g = 9.80665 (m/s2)

Because the accelerometer returns the values using a multidimensional device coordinate system, in our code we can calculate the distances along the x, y, and z axes using the following equations: Sx = AxT2/2

Sy=AyT2/2

Sz=AzT2/2

Where S_x, S_y, and S_z are the displacements on the x axis, y axis, and z axis, respectively, and A_x, A_y, and A_z are the accelerations on the x axis, y axis, and z axis, respectively. T is the time of the measurement period.

01	public class SensorDialog extends Dialog implements SensorEventListener {

02

…

03	private Sensor mSensor;

04	private SensorManager mSensorManager;

05

06	public SensorDialog(Context context) {

07	super(context);

08	mSensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);

09	mSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);

10

…

11

}

Code Example 3. Instantiation of an Accelerometer**

Sometimes we don’t use all three dimension data values. Other times we may also need to take the device’s orientation into consideration. For example, for a maze application, we only use the x-axis and y-axis gravitational acceleration to calculate the ball’s moving directions and distances based on the orientation of the device. The following code fragment (Code Example 4) outlines the logic.

01

@Override

02	public void onSensorChanged(SensorEvent event) {

03	if (event.sensor.getType() != Sensor.TYPE_ACCELEROMETER) {

04

return;

05

}

06	float accelX, accelY;

07

…

08	//detect the current rotation currentRotation from its “natural orientation”

09	//using the WindowManager

10	switch (currentRotation) {

11	case Surface.ROTATION_0:

12	accelX = event.values[0];

13	accelY = event.values[1];

14

break;

15	case Surface.ROTATION_90:

16	accelX = -event.values[0];

17	accelY = event.values[1];

18

break;

19	case Surface.ROTATION_180:

20	accelX = -event.values[0];

21	accelY = -event.values[1];

22

break;

23	case Surface.ROTATION_270:

24	accelX = event.values[0];

25	accelY = -event.values[1];

26

break;

27

}

28	//calculate the ball’s moving distances along x, and y using accelX, accelY and the time delta

29

…

30

}

31

}

Code Example 4. Considering the Device Orientation When Using the Accelerometer Data in a Maze Game**

Gyroscope

---

The gyroscope (or simply gyro) measures the device’s rate of rotation around the x , y, and z axes, as shown in Table 4. The gyroscope data values can be positive or negative. By looking at the origin from a position along the positive half of the axis, if the rotation is counterclockwise around the axis, the value is positive; if the rotation around the axis is clockwise, the value is negative. We can also determine the direction of a gyroscope value using the “right-hand rule,” illustrated in Figure 4.

Figure 4. Using the “right-hand rule” to decide the positive rotation direction

Sensor	Type	SensorEvent Data (rad/s)	Description
Gyroscope	TYPE_GYROSCOPE	values[0] values[1] values[2]	Rotation rate around the x axis Rotation rate around the y axis Rotation rate around the z axis

Table 4. The Gyroscope

Code Example 5 shows how to instantiate a gyroscope.

01	public class SensorDialog extends Dialog implements SensorEventListener {

02

…

03	private Sensor mGyro;

04	private SensorManager mSensorManager;

05

06	public SensorDialog(Context context) {

07	super(context);

08	mSensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);

09	mGyro = mSensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE);

10

…

11

}

Code Example 5. Instantiation of a Gyroscope**

Position Sensors

Many Android tablets support two position sensors: the magnetometer and the proximity sensors. The magnetometer measures the strengths of the Earth’s magnetic field along the x, y, and z axes, while the proximity sensor detects the distance of the device from another object.

 

Magnetometer

The most important usage of the magnetometer (described in Table 5) in Android systems is to implement the compass.

Sensor	Type	SensorEvent Data (µT)	Description
Magnetometer	TYPE_MAGNETIC_FIELD	values[0] values[1] values[2]	Earth magnetic field strength along the x axis Earth magnetic field strength along the y axis Earth magnetic field strength along the z axis

Table 5. The Magnetometer

Code Example 6 shows how to instantiate a magnetometer.

01	public class SensorDialog extends Dialog implements SensorEventListener {

02

…

03	private Sensor mMagnetometer;

04	private SensorManager mSensorManager;

05

06	public SensorDialog(Context context) {

07	super(context);

08	mSensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);

09	mMagnetometer = mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);

10

…

11

}

Code Example 6. Instantiation of a Magnetometer**

Proximity 

The proximity sensor provides the distance between the device and another object. The device can use it to detect if the device is being held close to the user (see Table 6), thus determining if the user is on a phone call and turning off the display during the phone call.

Table 6: The Proximity Sensor

Sensor	Type	SensorEvent Data	Description
Proximity	TYPE_PROXIMITY	values[0]	Distance from an object in cm. Some proximity sensors only report a Boolean value to indicate if the object is close enough.

Code Example 7 shows how to instantiate a proximity sensor.

01	public class SensorDialog extends Dialog implements SensorEventListener {

02

…

03	private Sensor mProximity;

04	private SensorManager mSensorManager;

05

06	public SensorDialog(Context context) {

07	super(context);

08	mSensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);

09	mProximity = mSensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY);

10

…

11

}

Code Example 7. Instantiation of a Proximity Sensor**

Environment Sensors 

The environment sensors detect and report the device’s ambient environment parameters, such as light, temperature, pressure, or humidity. The ambient light sensor (ALS) and the pressure sensor (barometer) are available on many Android tablets.

 

 Ambient Light Sensor (ALS)

The ambient light sensor, described in Table 7, is used by the system to detect the illumination of the surrounding environment and automatically adjust the screen brightness accordingly.

Table 7: The Ambient Light Sensor

Sensor	Type	SensorEvent Data (lx)	Description
ALS	TYPE_LIGHT	values[0]	The illumination around the device

Code Example 8 shows how to instantiate the ALS.

1

…

2	private Sensor mALS;

3	private SensorManager mSensorManager;

4

5

…

6	mSensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);

7	mALS = mSensorManager.getDefaultSensor(Sensor.TYPE_LIGHT);

8

…

Code Example 8. Instantiation of an Ambient Light Sensor**

Barometer

 

Applications can use the atmospheric pressure sensor (barometer), described in Table 8, to calculate the altitude of the device’s current location.

Table 8: The Atmosphere Pressure Sensor

Sensor	Type	SensorEvent Data (lx)	Description
Barometer	TYPE_PRESSURE	values[0]	The ambient air pressure in mbar

Code Example 9 shows how to instantiate the barometer.

1

…

2	private Sensor mBarometer;

3	private SensorManager mSensorManager;

4

5

…

6	mSensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);

7	mBarometer = mSensorManager.getDefaultSensor(Sensor.TYPE_PRESSURE);

8

…

Code Example 9. Instantiation of a barometer**

Sensor Performance and Optimization Guidelines

To use sensors in your applications, you should follow these best practices:

• Always check the specific sensor’s availability before using it
  The Android platform does not require the inclusion or exclusion of a specific sensor on the device. Before using a sensor in your application, always first check to see if it is actually available.
• Always unregister the sensor listeners
  If the activity that implements the sensor listener is becoming invisible, or the dialog is stopping, unregister the sensor listener. It can be done via the activity’s onPause() method, or in the dialog’s onStop() method. Otherwise, the sensor will continue acquiring data and as a result drain the battery.
• Don’t block the onSensorChanged() method
  The onSensorChanged() method is frequently called by the system to report the sensor data. You should put as little logic inside this method as possible. Complicated calculations with the sensor data should be moved outside of this method.
• Always test your sensor applications on real devices
  All sensors described in this section are hardware sensors. The Android Emulator may not be capable of simulating a particular sensor’s functions and performance.

GPS and Location

---

GPS (Global Positioning System) is a satellite-based system that provides accurate geo-location information around the world. GPS is available on many Android phones and tablets. In many perspectives GPS behaves like a position sensor. It can provide accurate location data for applications running on the device. On the Android platform, GPS is not directly managed by the sensor framework. Instead, the Android location service accesses and transfers GPS data to an application through the location listener callbacks.

 

This section only discusses the GPS and location services from a hardware sensor point of view. The complete location strategies offered by Android 4.2 and Intel Atom processor-based Android phones and tablets is a much larger topic and is outside of the scope of this section.

 

Android Location Services

Using GPS is not the only way to obtain location information on an Android device. The system can also use Wi-Fi*, cellular networks, or other wireless networks to get the device’s current location. GPS and wireless networks (including Wi-Fi and cellular networks) act as “location providers” for Android location services. Table 9 lists the main classes and interfaces used to access Android location services.

Table 9: The Android Platform Location Service

Name	Type	Description
LocationManager	Class	Used to access location services. Provides various methods for requesting periodic location updates for an application, or sending proximity alerts
LocationProvider	Abstract class	The abstract super class for location providers
Location	Class	Used by the location providers to encapsulate geographical data
LocationListener	Interface	Used to receive location notifications from the LocationManager

Obtaining GPS Location Updates

Similar to the mechanism of using the sensor framework to access sensor data, the application implements several callback methods defined in the LocationListener interface to receive GPS location updates. The LocationManager sends GPS update notifications to the application through these callbacks (the “Don’t call us, we’ll call you” rule).

To access GPS location data in the application, you need to request the fine location access permission in your Android manifest file (Code Example 10).

1	<manifest …>

2

…

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

4

…

5	</manifest>

Code Example 10. Requesting the Fine Location Access Permission in the Manifest File**

Code Example 11 shows how to get GPS updates and display the latitude and longitude coordinates on a dialog text view.

01	package com.intel.deviceinfo;

02

03	import android.app.Dialog;

04	import android.content.Context;

05	import android.location.Location;

06	import android.location.LocationListener;

07	import android.location.LocationManager;

08	import android.os.Bundle;

09	import android.widget.TextView;

10

11	public class GpsDialog extends Dialog implements LocationListener {

12	TextView mDataTxt;

13	private LocationManager mLocationManager;

14

15	public GpsDialog(Context context) {

16	super(context);

17	mLocationManager = (LocationManager)context.getSystemService(Context.LOCATION_SERVICE);

18

}

19

20

@Override

21	protected void onCreate(Bundle savedInstanceState) {

22	super.onCreate(savedInstanceState);

23	mDataTxt = (TextView) findViewById(R.id.sensorDataTxt);

24	mDataTxt.setText("...");

25

26	setTitle("Gps Data");

27

}

28

29

@Override

30	protected void onStart() {

31	super.onStart();

32	mLocationManager.requestLocationUpdates(

33	LocationManager.GPS_PROVIDER, 0, 0, this);

34

}

35

36

@Override

37	protected void onStop() {

38	super.onStop();

39	mLocationManager.removeUpdates(this);

40

}

41

42

@Override

43	public void onStatusChanged(String provider, int status,

44	Bundle extras) {

45

}

46

47

@Override

48	public void onProviderEnabled(String provider) {

49

}

50

51

@Override

52	public void onProviderDisabled(String provider) {

53

}

54

55

@Override

56	public void onLocationChanged(Location location) {

57	StringBuilder dataStrBuilder = new StringBuilder();

58	dataStrBuilder.append(String.format("Latitude: %.3f,   Logitude%.3fn", location.getLatitude(), location.getLongitude()));

59	mDataTxt.setText(dataStrBuilder.toString());

60

61

}

62

}

Code Example 11. A dialog that Displays the GPS Location Data**

GPS and Location Performance and Optimization Guidelines

GPS provides the most accurate location information on the device. On the other hand, as a hardware feature, it consumes extra energy. It also takes time for the GPS to get the first location fix. Here are some guidelines you should follow when developing GPS and location-aware applications:

• Consider all available location providers
  In addition to the GPS_PROVIDER, there is NETWORK_PROVIDER. If your applications only need coarse location data, you may consider using the NETWORK_PROVIDER.
• Use the cached locations
  It takes time for the GPS to get the first location fix. When your application is waiting for the GPS to get an accurate location update, you can first use the locations provided by the LocationManager’s getlastKnownLocation() method to perform part of the work.
• Minimize the frequency and duration of location update requests
  You should request the location update only when needed and promptly de-register from the location manager once you no longer need location updates.

For more information please visit: http://intel.ly/1hzvZ5o