Uso Del GPS en Android

UNI – FIIS ST324U Sistemas Operativos 1

TUTORIAL: USO DEL GPS EN ANDROID

CONFIGURACION DEL ENTORNO

Antes de empezar necesitamos algunos descargar e instalar algunos programas:

El SDK de Android: http://developer.android.com/sdk/index.html

El JDK y el JRE versión 6 o superior:

http://www.oracle.com/technetwork/java/javase/downloads/index.html

En entorno de programación será Eclipse Classic, la última versión disponible:

http://www.eclipse.org/downloads/

Primero instalamos el JDK, en la ubicación por defecto.

Luego, ejecutamos el instalador del SDK de Android y lo situamos en C:/SDKAndroid.

Cuando finalice ejecutamos el SDK Manager donde dejaremos los ya marcados y añadiremos, para

el tutorial, el paquete de la versión Android 2.3.3 (API 10) y hacemos click en “Install Packages”.

Una vez finalizada la descarga, agregamos una maquina virtual sobre la que se ejecutaran nuestras

aplicaciones. Abrimos en AVD Manager y agregamos un dispositivo haciendo click en New y

llenamos con estos datos:

http://www.oracle.com/technetwork/java/javase/downloads/index.html

http://www.eclipse.org/downloads/


Es importante que se fijen que en Hardware esta agregado GPS Support, para hacerlo debemos

hacer click en New y buscarlo en la lista. Pulsamos Crete AVD y es todo.

Ahora configuraremos Eclipse instalando el Android Development Toolkit (ADT). Para ello, una vez

abierto el entorno, vamos a Help – Install new software. Pulsamos en Add… En Name escribimos

“ADT” y en Location: https://dl-ssl.google.com/android/eclipse y luego OK. Esperamos a que

carguen los plugins y seleccionamos todos los disponibles y pulsamos Next y aceptamos los

términos de contrato que aparezcan.

Una vez terminado esto, reiniciamos el entorno Eclipse y estaremos listos para empezar a

programar.

PROGRAMACION

Creamos un Proyecto: File - New – Other y seleccionamos Android Application Project y Next

Rellenamos con estos datos y Next.

Ahora pulsamos Next, dejamos igual, Next, dejamos igual, y Finish. En el Package Explorer

buscamos MainActivity.java y lo abrimos:


Como se habran dado cuenta, el lenguaje usado para programar en Android es Java, por lo que

facilita la explicación.

Ahora importaremos las librerías necesarias para el uso del GPS del Android y de manejo del mapa

de Google Maps:

import java.util.ArrayList; import com.google.android.maps.*; import android.location.*; import android.content.*; import android.graphics.*; import android.graphics.drawable.*;

public class MainActivity extends Activity { @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); } @Override public boolean onCreateOptionsMenu(Menu menu) { getMenuInflater().inflate(R.menu.activity_main, menu); return true;


} }

Me parece que no es necesario explicar cada paquete, ya que su nombre explica casi todo. Y no

hay que alarmarse por las advertencias que salieron, solo indican que los paquetes se han

declarado, pero no han sido usados.

Ahora para usar el GPS del Android, la clase principal debe heredar de la clase MapActivity que

indica que mostraremos un mapa, a diferencia de una Activity, que es para mostrar botones,

cuadros de textos, etc. Y debe implementar un objeto LocationListener, que hara de receptor de

los mensajes que emitar el GPS del dispositivo, Para eso cambiamos:

public class MainActivity extends Activity {

por:

public class MainActivity extends MapActivity implements LocationListener {

Una vez hecho, nos saldrá un error al lado de la línea editada. Click en el icono del error y luego

seleccionamos Add unimplemented methods. Esto es porque el objeto LocationListener requiere

que se sobrecargue algunos métodos necesarios para su función.

Ahora para mostrar un punto en el mapa, debemos crear una clase que implemente este punto.

Para ello creamos miOverlay dentro de la clase principal y que herede de la clase

ItemizedOverlay<OverlayItem>, es decir una lista de capas que iran sobre el objeto. Es en esta lista

que se guardara los puntos que queremos que se dibuje en el mapa, pero para este tutorial solo

guardaremos un punto. Esta nueva clase también requiere métodos a sobrecargar, por lo que

hacemos el mismo procedimiento anterior y de la misma manera agregamos el constructor de la

clase. Y para trabajar mejor con la lista, la declaramos como un ArrayList de OverlayItem:

private ArrayList<OverlayItem> ListaItemsOverlay = new ArrayList<OverlayItem>();


public miOverlay(Drawable defaultMarker) { super(defaultMarker); // TODO Auto-generated constructor stub }

@Override protected OverlayItem createItem(int i) { // TODO Auto-generated method stub return null; } @Override public int size() { // TODO Auto-generated method stub return 0; }

Cambiaremos cada método según se indica abajo, y además sobrecargaremos el método Draw de

la clase y añadiremos el metodo addItem, que agregara un overlay dado unas coordenadas en el

ArrayList quedando así:

class miOverlay extends ItemizedOverlay<OverlayItem>{ private ArrayList<OverlayItem> ListaItemsOverlay = new ArrayList<OverlayItem>();

public miOverlay(Drawable defaultMarker) { super(boundCenterBottom(defaultMarker)); } public void addItem(GeoPoint p, String title, String snippet){ OverlayItem newItem = new OverlayItem(p, title, snippet); ListaItemsOverlay.add(newItem); populate(); } @Override protected OverlayItem createItem(int i) { return ListaItemsOverlay.get(i); } @Override public int size() { return ListaItemsOverlay.size(); } @Override public void draw(Canvas canvas, MapView mapView, boolean shadow) { super.draw(canvas, mapView, shadow); } }

Borraremos lo de abajo porque ya no es necesario, ya que no haremos un menú en este tutorial. @Override public boolean onCreateOptionsMenu(Menu menu) { getMenuInflater().inflate(R.menu.activity_main, menu);


return true; }

Antes de continuar, debemos editar el archivo activity_main.xml autogenerado durante la

creación del proyecto. Lo reemplazaremos por estas líneas:

<?xml version="1.0" encoding="utf-8"?> <com.google.android.maps.MapView xmlns:android="http://schemas.android.com/apk/res/android" android:id="@+id/mapview" android:layout_width="fill_parent" android:layout_height="fill_parent" android:clickable="true" android:apiKey="0TFdNTjD4k_prXEsHKGFi60V3SbMrFhR3FPZogw" />

Los archivos XML se usan para crear las interfaces, lo que vera el usuario. Se hace esto aparte para

poder separar lo que es lógica de la aplicación de la interfaz del usuario y tener un código mas

limpio.

En este código com.google.android.maps.MapView indica que estamos colocando un objeto

Mapa idéntico al de Google Maps en la pantalla, android:id="@+id/mapview" asigna un código

al objeto para poder buscarlo y trabajarlo desde código java, y las demás líneas son para indicar

que se ajuste a toda la pantalla y se pueda navegar con el dedo.

La ultima línea es todo un caso. Ese código es una clave que te da Google como desarrollador y

que te otorga acceso al uso de sus API’s. La generación de este código se indica al final de esta

parte del tutorial.


Ahora que estamos con los XML, aprovecharemos para editar el AndroidManifest.xml

Este archivo es como un resumen de la aplicación, muestra el nombre, que activades tendrá, que

permisos de acceso, que librerías usara, etc. Modificaremos su contenido para que quede asi:

<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.migps" android:versionCode="1" android:versionName="1.0" > <uses-sdk android:minSdkVersion="8" android:targetSdkVersion="15" /> <uses-permission android:name="android.permission.INTERNET" /> <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" /> <application android:icon="@drawable/ic_launcher" android:label="@string/app_name" android:theme="@style/AppTheme" > <activity android:name=".MainActivity" android:label="@string/title_activity_main" > <intent-filter> <action android:name="android.intent.action.MAIN" /> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </activity> <uses-library android:name="com.google.android.maps" /> </application> </manifest>

Lo que aquí agregamos son los permisos para internet y para usar el GPS, y mas abajo indicamos

que usaremos las librerías de googlemaps

Luego de editar este código volvemos a MainActivity.Java y agregamos líneas al metodo onCreate.

@Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); MapView mapView = (MapView) findViewById(R.id.mapview); mapView.setBuiltInZoomControls(true); mapView.setSatellite(true); Location fiis = new Location("gps"); fiis.setLatitude(-12.015511); fiis.setLongitude(-77.050411); updateLocation(fiis); LocationManager locationManager = (LocationManager)getSystemService(Context.LOCATION_SERVICE);


locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, this); MapController mapController = mapView.getController(); mapController.setZoom(18); }

Este metodo es el primero que se llama cuando se inicia la actividad. Lo que hacemos en todo este

metodo es:

super.onCreate(savedInstanceState); llama al metodo onCreate de la clase madre para que

responda a la estado que esta recibiendo. Esto es útil cuando por ejemplo queremos que la

aplicación haga algo depues que se haya minimizado y volvamos a el.

setContentView(R.layout.activity_main); muestra en pantalla el achivo xml que hemos

editado antes.

MapView mapView = (MapView) findViewById(R.id.mapview); Obtenemos la referencia al mapview insertado en el XML. mapView.setBuiltInZoomControls(true); mostramos los controles de zoom

mapView.setSatellite(true); y establecemos la vista satelital. Location fiis = new Location("gps"); Creamos una locación y la llamamos fiis. Este objeto encapsulara las coordenadas de un punto inicial que será la facultad. fiis.setLatitude(-12.015511); fiis.setLongitude(-77.050411);

updateLocation(fiis); este metodo lo implementaremos terminando con onCreate,

pero lo que hace es insertar ese punto en el mapa

LocationManager locationManager = (LocationManager)getSystemService(Context.LOCATION_SERVICE); locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0,

this); con estas líneas capturamos el contexto del servicio de locación, y lo modificamos para

que el GPS nos informe sobre algún cambio lo mas pronto posible, por eso el valor de ceros como

parámetros.

MapController mapController = mapView.getController();

mapController.setZoom(18); Obtenemos un controlador del mapview, para poder establecer

un nivel de zoom adecuado.

Ahora el código para el updateLocation:

protected void updateLocation(Location location){ MapView mapView = (MapView) findViewById(R.id.mapview); MapController mapController = mapView.getController(); GeoPoint point = new GeoPoint((int) (location.getLatitude() * 1E6), (int) (location.getLongitude() * 1E6)); mapController.animateTo(point);


Drawable marker=getResources().getDrawable(android.R.drawable.star_big_on); int markerWidth = marker.getIntrinsicWidth(); int markerHeight = marker.getIntrinsicHeight(); marker.setBounds(0, 0,markerHeight, markerWidth); miOverlay myItemizedOverlay = new miOverlay(marker); mapView.getOverlays().clear(); mapView.getOverlays().add(myItemizedOverlay); GeoPoint myPoint1 = new GeoPoint((int) (location.getLatitude() * 1E6), (int) (location.getLongitude() * 1E6)); myItemizedOverlay.addItem(myPoint1, "", ""); }

Lo primero que hacemos es volver a tener la referencia al mapview del código XML, y un

controlador para el mismo. Ubicamos las coordenadas recibidas como parámetro (location) dentro

del mapa.

Ahora definimos lo que queremos dibujar en pantalla. Usare un archivo que viene con la

instalación del api de google para no estar buscando otro. Luego a partir de su altura y anchura se

crea los márgenes de esta marca.

Creamos un objeto miOverlay y le enviamos nuestra marca como parámetro. Capturamos las

overlays antes dibujadas y las borramos y agregamos la nueva, asi solo habrá un punto en el mapa.

Ahora solo nos falta modificar el onLocationChanged por:

public void onLocationChanged(Location location) { updateLocation(location); }

Este metodo se lanza cuando el GPS detecta que hubo un cambio respecto al ultimo punto

recibido.

Y eso es todo, ejecutamos: seleccionamos Android Application


Esperamos un tiempo y la aplicación habrá cargado:


Para probar que funciona, podemos ingresar coordenadas en el Eclipse mediante el DDMS.

Buscamos Location Controls y en la pesañ manual ingresamos las coordenadas.

Ahora si quisiéramos simular una camitana, seria ingresar un monton de puntos, pero es algo

tedioso, por lo que la mejor solución es crear un archivo KML e importarlo al Eclipse. Junto a este

tutorial adjunto un archivo Puntos de Prueba.kml con lo que pueden simular una caminata en la

universidad.

OBTENER EL APIKEY DE GOOGLE

Como lo había dicho, el apikey es el código que te otorga google como desarrollador y te permite

usar sus apis en tus aplicaciones. Este código es único y será necesario mientras desarrollemos la

aplicación.

Ejecuta cmd, y ubica la carpeta donde tenemos instalado el jre con el comando cd:

En mi caso seria esto:


Luego escriben esto:

keytool.exe -list -keystore "C:\Users\NpsteR\.android\debug.keystore" -storepass android -

keypass android. Esta claro que la ruta que sale deben reemplazarlo por la de su sistema. Cuando

lo ejecuten les saldra su codigo en MD5 para poder registrarse en Google Developers.

Esto es lo mas importante:

Huella digital de certificado (MD5): 60:4E:12:06:1A:D9:ED:5F:3A:15:53:9A:6B:19:26:E2

Copiamos ese codigo y entramos a esta pagina: https://developers.google.com/android/maps-api-

signup?hl=es

Aceptamos los términos, pegamos el codigo y click en el boton Generate Api Key

Luego se abrira una nueva ventana donde saldra su clave android de Apimaps, en mi caso es:

0TFdNTjD4k_prXEsHKGFi60V3SbMrFhR3FPZogw

Y este código deben reemplazarlo en el archivo activity_main.xml exactamente en esta parte:

android:apiKey="0TFdNTjD4k_prXEsHKGFi60V3SbMrFhR3FPZogw"

Colocan su código y listo.

Documents

Uso Del GPS en Android