Desarrollo de aplicaciones de sensores en teléfonos y tabletas Android* basados en el procesador Intel® Atom™

Desarrollo de aplicaciones de sensores en teléfonos y tabletas Android* basados en el procesador Intel® Atom™

Esta guía proporciona a los desarrolladores de aplicaciones una introducción al framework de Android para sensores y describe cómo utilizar algunos de los sensores que generalmente están disponibles en teléfonos y tabletas basados en el procesador Intel® Atom™. Entre los puntos a tratar se encuentran los sensores de movimiento, posición y entorno. Aunque el GPS no se categoriza estrictamente como un sensor en el framework de Android, esta guía también describe los servicios de ubicación basada en GPS. La descripción es esta guía se basa en Android 4.2, Jelly Bean.

Sensores en teléfonos y tabletas Android basados en el procesador Intel® Atom™

Los teléfonos y tabletas Android basados en procesadores Intel Atom son compatibles en una gama amplia de sensores de hardware. Estos sensores se utilizan para detectar movimiento y cambios de posición y declarar los parámetros de entorno ambiental. El diagrama de bloques en la Ilustración 1 muestra una posible configuración de sensores en un dispositivo Android típico basado en el procesador Intel Atom.

Ilustración 1. Sensores en un sistema Android basado en Intel® Atom™

Basados en los datos que generan, podemos categorizar los sensores Android en las clases y tipos que se muestran en la Tabla 1.

Tabla 1. Tipos de sensores compatibles con la plataforma Android
 

Framework de Android para sensores

El framework de Android para sensores proporciona mecanismos para acceder a los sensores y datos de sensores, con la excepción del GPS, al cual se accede mediante los servicios de ubicación para Android. Mas adelante, este documento incluye detalles al respecto. El framework para sensores es parte del paquete android.hardware. La Tabla 2 incluye las clases e interfaces principales del framework para sensores.

Tabla 2. Framework para sensores de la plataforma Android

Obtención de la configuración del sensor

Los fabricantes de dispositivos deciden qué sensores están disponibles en el dispositivo. Debe detectar qué sensores están disponibles en el tiempo de ejecución invocando el método SensorManager getSensorList() del framework para sensores con un parámetro “Sensor.TYPE_ALL”. El Ejemplo de código 1 muestra una lista de los sensores disponibles y la información sobre proveedores, energía y precisión de cada sensor.

package com.intel.deviceinfo;
	
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import android.app.Fragment;
import android.content.Context;
import android.hardware.Sensor;
import android.hardware.SensorManager;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ListView;
import android.widget.SimpleAdapter;
	
public class SensorInfoFragment extends Fragment {
	
    private View mContentView;
	
    private ListView mSensorInfoList;	
    SimpleAdapter mSensorInfoListAdapter;
	
    private List<Sensor> mSensorList;

    private SensorManager mSensorManager;
	
    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
    }
	
    @Override
    public void onPause() 
    { 
        super.onPause();
    }
	
    @Override
    public void onResume() 
    {
        super.onResume();
    }
	
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
            Bundle savedInstanceState) {
        mContentView = inflater.inflate(R.layout.content_sensorinfo_main, null);
        mContentView.setDrawingCacheEnabled(false);
	
        mSensorManager = (SensorManager)getActivity().getSystemService(Context.SENSOR_SERVICE);
	
        mSensorInfoList = (ListView)mContentView.findViewById(R.id.listSensorInfo);
		
        mSensorInfoList.setOnItemClickListener( new OnItemClickListener() {
			
            @Override
            public void onItemClick(AdapterView<?> arg0, View view, int index, long arg3) {
				
                // with the index, figure out what sensor was pressed
                Sensor sensor = mSensorList.get(index);
				
                // pass the sensor to the dialog.
                SensorDialog dialog = new SensorDialog(getActivity(), sensor);

                dialog.setContentView(R.layout.sensor_display);
                dialog.setTitle("Sensor Data");
                dialog.show();
            }
        });
		
        return mContentView;
    }
	
    void updateContent(int category, int position) {
        mSensorInfoListAdapter = new SimpleAdapter(getActivity(), 
	    getData() , android.R.layout.simple_list_item_2,
	    new String[] {
	        "NAME",
	        "VALUE"
	    },
	    new int[] { android.R.id.text1, android.R.id.text2 });
	mSensorInfoList.setAdapter(mSensorInfoListAdapter);
    }
	
	
    protected void addItem(List<Map<String, String>> data, String name, String value)   {
        Map<String, String> temp = new HashMap<String, String>();
        temp.put("NAME", name);
        temp.put("VALUE", value);
        data.add(temp);
    }
	
	
    private List<? extends Map<String, ?>> getData() {
        List<Map<String, String>> myData = new ArrayList<Map<String, String>>();
        mSensorList = mSensorManager.getSensorList(Sensor.TYPE_ALL);
		
        for (Sensor sensor : mSensorList ) {
            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());
        }
        return myData;
    }
}

Ejemplo de código 1. Un fragmento que muestra la lista de sensores**

Sistema de coordenadas de sensores

El framework para sensores declara los datos de sensores utilizando un sistema estándar de coordenadas con 3 ejes, donde X, Y y Z son representados por values[0], values[1] y values[2] en el objeto SensorEvent, respectivamente.

Algunos sensores, tales como la luz, temperatura, proximidad y presión, devuelven solo valores individuales. Para estos sensores solo se utilizan values[0] en el objeto SensorEvent.

Otros sensores declaran datos en el sistema estándar de coordenadas de sensores con 3 ejes. A continuación se encuentra una lista de dichos sensores:

• Acelerómetro
• Sensor de gravedad
• Giroscopio
• Sensor del campo geomagnético

El sistema de coordenadas de sensores con 3 ejes se define en relación a la pantalla del dispositivo en su orientación natural (predeterminada). Para un teléfono la orientación predeterminada es vertical, para una tableta la orientación natural es horizontal. Cuando un dispositivo se sostiene en su orientación natural, el eje x es horizontal y apunta a la derecha, el eje y es vertical y apunta hacia arriba y el eje z apunta fuera de la pantalla (parte frontal). La Ilustración 2 muestra el sistema de coordenadas de sensores para un teléfono y la Ilustración 3 para una tableta.

Ilustración 2. El sistema de coordenadas de sensores para un teléfono

Ilustración 3.  El sistema de coordenadas de sensores para una tableta

Lo más importante sobre el sistema de coordenadas de sensores es que nunca cambia cuando el dispositivo se mueve o cambia de orientación.

Supervisión de eventos del sensor

El framework para sensores informa sobre los datos del sensor con objetos SensorEvent. Una clase puede supervisar datos de un sensor específico al implementar la interfaz SensorEventListener y registrar con SensorManager para el sensor específico. El framework para sensores informa a la clase sobre los cambios en los estados del sensor mediante los dos siguientes métodos de llamadas de regreso SensorEventListener que la clase implementa:

onAccuracyChanged()

y

onSensorChanged()

El Ejemplo de código 2 implementa el SensorDialog utilizado en el ejemplo de SensorInfoFragment que describimos en la sección “Obtención de la configuración del sensor”.

package com.intel.deviceinfo;

import android.app.Dialog;
import android.content.Context;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.os.Bundle;
import android.widget.TextView;

public class SensorDialog extends Dialog implements SensorEventListener {
    Sensor mSensor;
    TextView mDataTxt;
    private SensorManager mSensorManager;

    public SensorDialog(Context ctx, Sensor sensor) {
        this(ctx);
        mSensor = sensor;
    }
	
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mDataTxt = (TextView) findViewById(R.id.sensorDataTxt);
        mDataTxt.setText("...");
        setTitle(mSensor.getName());
    }
	
    @Override
    protected void onStart() {
        super.onStart();
        mSensorManager.registerListener(this, mSensor,  SensorManager.SENSOR_DELAY_FASTEST);
    }
		
    @Override
    protected void onStop() {
        super.onStop();
        mSensorManager.unregisterListener(this, mSensor);
    }

    @Override
    public void onAccuracyChanged(Sensor sensor, int accuracy) {
    }

    @Override
    public void onSensorChanged(SensorEvent event) {
        if (event.sensor.getType() != mSensor.getType()) {
            return;
        }
        StringBuilder dataStrBuilder = new StringBuilder();
        if ((event.sensor.getType() == Sensor.TYPE_LIGHT)||
            (event.sensor.getType() == Sensor.TYPE_TEMPERATURE)||
            (event.sensor.getType() == Sensor.TYPE_PRESSURE)) {
            dataStrBuilder.append(String.format("Data: %.3fn", event.values[0]));
        }
        else{         
            dataStrBuilder.append( 
                String.format("Data: %.3f, %.3f, %.3fn", 
                event.values[0], event.values[1], event.values[2] ));
        }
        mDataTxt.setText(dataStrBuilder.toString());
    }
}

Ejemplo de código 2.Un diálogo que muestra los valores de sensor**

Sensores de movimiento

Los sensores de movimiento se utilizan para supervisar los movimientos del dispositivo, tales como una sacudida, rotación, oscilación o inclinación. El acelerómetro y giroscopio son dos sensores de movimiento disponibles en muchas tabletas y teléfonos.

Los sensores de movimiento informan sobre datos mediante el sistema de coordenadas de sensores, donde los tres valores en el objeto SensorEvent, values[0], values[1] y values[2], representan los valores de los ejes x-, y- y z-, respectivamente.

Para comprender los sensores de movimiento y aplicar los datos en una aplicación, necesitamos aplicar algunas fórmulas físicas relacionadas con fuerza, masa, aceleración, leyes de movimiento de Newton y la relación entre varias de estas entidades en el tiempo. Para familiarizarse más con estas fórmulas y sus relaciones, consulte sus manuales de física favoritos o fuentes de dominio público.

Acelerómetro

El acelerómetro mide la aceleración aplicada al dispositivo y sus propiedades se resumen en la Tabla 3.

Tabla 3. El acelerómetro

El concepto para el acelerómetro proviene de la segunda ley de movimiento de Newton:

a = F/m

La aceleración de un objeto es el resultado de la fuerza neta externa aplicada al objeto. Las fuerzas externas incluyen una que afecta a todos los objetos en la tierra, la gravedad. Es proporcional a la fuerza neta F aplicada al objeto y proporcionalmente inversa a la masa m del objeto.

En nuestro código, en lugar de usar directamente la ecuación anterior, nos preocupa más el resultado de la aceleración durante un período de tiempo de la velocidad y posición del dispositivo. La siguiente ecuación describe la relación de la velocidad de un objeto v1, su velocidad original v0, la aceleración a y el tiempo t:

v1 = v0 + at

Para calcular la posición del objeto con un desplazamiento s, utilizamos la siguiente ecuación:

s = v0t + (1/2)at2

En la mayoría de los casos, comenzamos con la condición v0 igual a 0 (antes de que el dispositivo comience a moverse) lo cual simplifica la ecuación a:

s = at2/2

Debido a la gravedad, la aceleración gravitacional, representada con el símbolo g, afecta a todos los objetos en la tierra. Sin tener en cuenta la masa del objeto, g solo depende de la latitud de la ubicación del objeto con un valor que oscila entre 9.78 y 9.82 (m/s^{2). Adoptamos un valor estándar convencional para g:}

g = 9.80665 (m/s2)

Debido a que el acelerómetro genera los valores usando un sistema de coordenadas para dispositivos multidimensionales, en nuestro código calcularemos las distancias en los ejes x, y, y z con las siguientes ecuaciones:

Sx = AxT2/2

Sy=AyT2/2

Sz=AzT2/2

Donde S_x, S_y y S_z son los desplazamientos en el eje x, el eje y, y el eje z, respectivamente, y A_x, A_y y A_z son las aceleraciones en el eje x, eje y, y eje z, respectivamente. T es el tiempo del período de medida.

public class SensorDialog extends Dialog implements SensorEventListener {
    …	
    private Sensor mSensor;
    private SensorManager mSensorManager;
	
    public SensorDialog(Context context) {
        super(context);
        mSensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);
        mSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
    …
}

Ejemplo de código 3. Creación de una instancia de acelerómetro**

A veces no utilizamos los tres valores de datos de dimensión. Otras veces, puede que también necesitemos tener en cuenta la orientación del dispositivo. Por ejemplo, para una aplicación de laberinto, solamente usamos la aceleración gravitacional del eje x y el eje y para calcular las direcciones de los movimientos de la bola y las distancias según la orientación del dispositivo. El siguiente fragmento de código (Ejemplo de código 4) define la lógica.

@Override
public void onSensorChanged(SensorEvent event) {
    if (event.sensor.getType() != Sensor.TYPE_ACCELEROMETER) {
        return;
    } 
float accelX, accelY;
…
//detect the current rotation currentRotation from its “natural orientation”
//using the WindowManager
    switch (currentRotation) {
        case Surface.ROTATION_0:
            accelX = event.values[0];
            accelY = event.values[1];
            break;
        case Surface.ROTATION_90:
            accelX = -event.values[0];
            accelY = event.values[1];
            break;
        case Surface.ROTATION_180:
            accelX = -event.values[0];
            accelY = -event.values[1];
            break;
        case Surface.ROTATION_270:
            accelX = event.values[0];
            accelY = -event.values[1];
            break;
    }
    //calculate the ball’s moving distances along x, and y using accelX, accelY and the time delta
        …
    }
}

Ejemplo de código 4.Consideración de la orientación del dispositivo al usar los datos del acelerómetro en un juego de laberinto**

Giroscopio

El giroscopio (en inglés se conoce solo como gyro) mide la velocidad de rotación del dispositivo alrededor de los ejes x , y, y z, tal como se muestra en la Tabla 4. Los valores de los datos del giroscopio pueden ser positivos o negativos. Al observar el origen de una posición a lo largo de la mitad positiva del eje, si la rotación se produce en dirección contraria a las manecillas de un reloj alrededor del eje, el valor es positivo; caso contrario, el valor es negativo. También podemos determinar la dirección de un valor del giroscopio con la "regla de la mano derecha" como se muestra en la Ilustración 4.

Ilustración 4. Uso de la “regla de la mano derecha” para decidir la dirección de rotación positiva

Tabla 4. El giroscopio

El Ejemplo de código 5 muestra cómo crear una instancia de giroscopio.

public class SensorDialog extends Dialog implements SensorEventListener {
    …	
    private Sensor mGyro;
    private SensorManager mSensorManager;
	
    public SensorDialog(Context context) {
        super(context);
        mSensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);
        mGyro = mSensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE);
    …
}

Ejemplo de código 5. Creación de una instancia de giroscopio**

Sensores de posición

Muchas tabletas Android admiten dos sensores de posición: los sensores de magnetómetro y de proximidad. El magnetómetro mide la intensidad del campo magnético de la tierra a lo largo de los ejes x, y, y z, mientras que el sensor de proximidad detecta la distancia del dispositivo con respecto a otro objeto.

Magnetómetro

El uso más importante del magnetómetro (descrito en la Tabla 5) en sistemas para Android es implementar la brújula.

Tabla 5. El magnetómetro

El Ejemplo de código 6 muestra cómo crear una instancia de magnetómetro.

public class SensorDialog extends Dialog implements SensorEventListener {
    …	
    private Sensor mMagnetometer;
    private SensorManager mSensorManager;
	
    public SensorDialog(Context context) {
        super(context);
        mSensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);
        mMagnetometer = mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);
    …
}

Ejemplo de código 6. Creación de una instancia de magnetómetro**

Proximidad

El sensor de proximidad proporciona la distancia entre el dispositivo y otro objeto. El dispositivo puede utilizarlo para detectar si el usuario sostiene el dispositivo cerca (consulte la Tabla 6); por lo tanto, podrá determinar si el usuario se encuentra en una llamada telefónica y podrá apagar la pantalla durante la llamada telefónica.

El Ejemplo de código 7 muestra cómo crear una instancia de sensor de proximidad.

public class SensorDialog extends Dialog implements SensorEventListener {
    …	
    private Sensor mProximity;
    private SensorManager mSensorManager;
	
    public SensorDialog(Context context) {
        super(context);
        mSensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);
        mProximity = mSensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY);
    …
}

Ejemplo de código 7. Creación de una instancia de sensor de proximidad**

Sensores ambientales

Los sensores ambientales detectan e informan de los parámetros ambientales del entorno del dispositivo, tales como la luz, temperatura, presión o humedad. El sensor de luz ambiental (ALS) y el sensor de presión (barómetro) están disponibles en muchas tabletas Android.

Sensor de luz ambiental (ALS)

El sistema utiliza el sensor de luz ambiental, descrito en la Tabla 7, para detectar la iluminación del entorno y ajustar automáticamente el brillo de la pantalla al nivel adecuado.

El Ejemplo de código 8 muestra cómo crear una instancia de ALS.

…	
    private Sensor mALS;
    private SensorManager mSensorManager;

    …	
        mSensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);
        mALS = mSensorManager.getDefaultSensor(Sensor.TYPE_LIGHT);
    …

Ejemplo de código 8.Creación de una instancia de sensor de luz ambiental**

Barómetro

Las aplicaciones pueden utilizar el sensor de presión atmosférica (barómetro), descrito en la Tabla 8, para calcular la altura de la ubicación actual del dispositivo.

El Ejemplo de código 9 muestra cómo crear una instancia de barómetro.

…	
    private Sensor mBarometer;
    private SensorManager mSensorManager;

    …	
        mSensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);
        mBarometer = mSensorManager.getDefaultSensor(Sensor.TYPE_PRESSURE);
    …

Ejemplo de código 9. Creación de una instancia de barómetro**

Directrices para el rendimiento y optimización del sensor

Para utilizar sensores en sus aplicaciones, debe seguir estas prácticas recomendadas:

• Compruebe siempre la disponibilidad del sensor específico antes de utilizarlo
  La plataforma Android no requiere la inclusión o exclusión de un sensor específico en el dispositivo. Antes de utilizar un sensor en su aplicación, siempre revise primero para ver si está disponible.
• Elimine siempre los registros de las escuchas del sensor
  Si la actividad que implementa la escucha del sensor se está volviendo invisible o si el diálogo se está deteniendo, elimine el registro de la escucha del sensor. Puede hacerlo mediante el método onPause() de la actividad o el método onStop() del diálogo. Caso contrario, el sensor continuará adquiriendo datos y, como resultado, drenará la batería.
• No bloquee el método onSensorChanged()
   El sistema llama frecuentemente al método onSensorChanged() para declarar los datos del sensor. Debe poner tan poca lógica en este método como sea posible. Los cálculos complicados con los datos del sensor deben sacarse de este método.
• Pruebe siempre las aplicaciones de su sensor en dispositivos reales
   Todos los sensores descritos en esta sección son sensores de hardware. El Emulador de Android puede que no sea capaz de simular las funciones y el rendimiento de un sensor particular.

GPS y reconocimiento de ubicación

GPS (Sistema de posicionamiento global) es un sistema basado en satélites que proporciona información precisa sobre ubicación geográfica en todo el mundo. GPS está disponible en muchos teléfonos y tabletas Android. En muchos aspectos el GPS se comporta como un sensor de posición. Puede proporcionar datos precisos de la ubicación para aplicaciones que se ejecutan en el dispositivo. En la plataforma Android, el framework para sensores no administra directamente el GPS. En su lugar, el servicio de ubicación de Android accede y transfiere datos del GPS a una aplicación por medio de las llamadas de regreso de la escucha de ubicación.

Esta sección solo trata el GPS y los servicios de ubicación desde el punto de vista del sensor de hardware. La estrategia de ubicación completa que ofrecen los teléfonos y tabletas Android 4.2 basados en el procesador Intel Atom es un tema mucho más extenso y no será incluido en esta sección.

Servicios de ubicación Android

El uso del GPS no es la única manera de obtener información sobre la ubicación en un dispositivo Android. El sistema también puede utilizar Wi-Fi*, redes de celulares u otras redes inalámbricas para obtener la ubicación actual del dispositivo. El GPS y las redes inalámbricas (incluyendo Wi-Fi y redes de celulares) actúan como “proveedores de ubicación” para servicios de ubicación Android. La Tabla 9 incluye las clases e interfaces principales que se utilizan para acceder los servicios de ubicación Android.

Cómo obtener actualizaciones de ubicación del GPS

De manera similar al mecanismo de uso del framework para sensores para acceder los datos del sensor, la aplicación implementa varios métodos de llamadas de regreso definidos en la interfaz de LocationListener para recibir actualizaciones de ubicación del GPS. LocationManager envía avisos de actualizaciones del GPS a la aplicación mediante estas llamadas de regreso (la regla de “No nos llame, nosotros le llamaremos”).

Para acceder los datos de ubicación del GPS en la aplicación, necesita solicitar permiso de acceso a la ubicación precisa en su archivo de manifiesto Android (Ejemplo de código 10).

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

Ejemplo de código 10.Cómo solicitar permiso de acceso a la ubicación precisa en el archivo de manifiesto**

El Ejemplo de código 11 muestra cómo obtener actualizaciones para el GPS y mostrar las coordenadas de latitud y longitud en la vista del texto del diálogo.

package com.intel.deviceinfo;

import android.app.Dialog;
import android.content.Context;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.os.Bundle;
import android.widget.TextView;

public class GpsDialog extends Dialog implements LocationListener {
    TextView mDataTxt;
    private LocationManager mLocationManager;
	
    public GpsDialog(Context context) {
        super(context);
        mLocationManager = (LocationManager)context.getSystemService(Context.LOCATION_SERVICE);
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
	       mDataTxt = (TextView) findViewById(R.id.sensorDataTxt);
          mDataTxt.setText("...");
		
        setTitle("Gps Data");
    }
	
    @Override
    protected void onStart() {
        super.onStart();
        mLocationManager.requestLocationUpdates(
            LocationManager.GPS_PROVIDER, 0, 0, this);
    }
		
    @Override
    protected void onStop() {
        super.onStop();
        mLocationManager.removeUpdates(this);
    }

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

    @Override
    public void onProviderEnabled(String provider) {
    }

    @Override
    public void onProviderDisabled(String provider) {
    }

    @Override
    public void onLocationChanged(Location location) {
        StringBuilder dataStrBuilder = new StringBuilder();
        dataStrBuilder.append(String.format("Latitude: %.3f,   Logitude%.3fn", location.getLatitude(), location.getLongitude()));
        mDataTxt.setText(dataStrBuilder.toString());
		
    }
}

Ejemplo de código 11. Un diálogo que muestra los datos de ubicación del GPS**

Directrices de rendimiento y optimización del GPS y de la ubicación

El GPS proporciona la información de ubicación más exacta sobre el dispositivo. Por otro lado, al ser una función del hardware, consume energía adicional. También se requiere tiempo para que el GPS fije la primera ubicación. Estas son algunas directrices que debe seguir cuando desarrolle aplicaciones que reconozcan el GPS y la ubicación:

• Considere todos los proveedores de ubicación disponibles
   Además de GPS_PROVIDER, existe NETWORK_PROVIDER. Si sus aplicaciones solo necesitan datos de ubicación 'brutos', considere el uso de NETWORK_PROVIDER.
• Utilice las ubicaciones de la memoria caché
  Se requiere tiempo para que el GPS fije la primera ubicación. Mientras su aplicación espera a que el GPS obtenga una actualización de ubicación exacta, primero puede usar las ubicaciones proporcionadas por el método getlastKnownLocation() de LocationManager para realizar parte del trabajo.
• Minimice la frecuencia y duración de las solicitudes de actualizaciones de ubicación
  Debe solicitar la actualización de ubicaciones solo cuando sea necesario y eliminar rápidamente el registro desde el administrador de ubicaciones una vez que deje de necesitar actualizaciones de ubicación.

Resumen

La plataforma Android proporciona las API para que los desarrolladores accedan los sensores integrados de un dispositivo. Estos sensores tienen la capacidad de proporcionar datos brutos sobre las condiciones del movimiento, posición y entorno ambiental actuales del dispositivo con alta precisión y exactitud. Al desarrollar aplicaciones de sensores, debe seguir las mejores prácticas para mejorar el rendimiento y el consumo eficaz de energía.

Sobre el autor

Copyright © 2013 Intel Corporation. Todos los derechos reservados.
*Las demás marcas y nombres podrían ser considerados como propiedad de terceros.

**Este ejemplo de código fuente se publica según el Contrato de licencia de código fuente de muestra de Intel