http://hellogreenrules.blogspot.
com/2012/12/google-maps-
api-v2-mapfragment.html
Google Maps API v2. MapFragment
Por fin!
Los mapas y los Fragments ya se ha unificado. A continuación y sin andarse mucho por las ramas
el ejemplo de como añadirlo y como manejar el GoogleMaps.
1.- Necesitamos la API Key que se obtiene de forma distinta a los MapActivity. En el siguiente
enlace se detallan los pasos de como obtenerla. Obtener API KEY
2.- Descargar del SDK Manager -> Extras -> Google Play services.
3.- Importar en libs el archivo jar. AndroidSDK -> Extras -> Google -> Google Play Services -> libs
-> google-play-services.jar
4.- Ya podemos empezar a generar el código.
AndroidManifest.xml
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.maps.fragments"
android:versionCode="1"
android:versionName="1.0" >
<uses-sdk
android:minSdkVersion="8"
android:targetSdkVersion="16" />
<uses-feature
android:glEsVersion="0x00020000"
android:required="true" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-
permissionandroid:name="com.google.android.providers.gsf.permission.READ_GSERVICES" />
<permission
android:name="com.example.maps.fragments.permission.MAPS_RECEIVE"
android:protectionLevel="signature" />
<uses-
permission android:name="com.example.maps.fragments.permission.MAPS_RECEIVE" />
<application
android:allowBackup="true"
android:icon="@drawable/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme" >
<activity
android:name="com.example.maps.fragments.MainActivity"
android:label="@string/app_name" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<!-- API KEY -->
<meta-data
android:name="com.google.android.maps.v2.API_KEY"
android:value="AIzaSyA-v3ukHyXbPP0db9khnT6pwzNzMfM79Nw" />
</application>
</manifest>
MainActivity.java
package com.example.maps.fragments;
import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import com.google.android.gms.maps.CameraUpdateFactory;
import com.google.android.gms.maps.GoogleMap;
import com.google.android.gms.maps.MapFragment;
import com.google.android.gms.maps.model.BitmapDescriptorFactory;
import com.google.android.gms.maps.model.CameraPosition;
import com.google.android.gms.maps.model.LatLng;
import com.google.android.gms.maps.model.Marker;
import com.google.android.gms.maps.model.MarkerOptions;
public class MainActivity extends Activity implements OnClickListener {
private GoogleMap mMap;
private static final LatLng MY_POINT = new LatLng(41.66, 1.54);
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// Init view elements
((Button) findViewById(R.id.none)).setOnClickListener(this);
((Button) findViewById(R.id.satellite)).setOnClickListener(this);
((Button) findViewById(R.id.hybrid)).setOnClickListener(this);
((Button) findViewById(R.id.normal)).setOnClickListener(this);
((Button) findViewById(R.id.terrain)).setOnClickListener(this);
// Verify Map availability
setUpMapIfNeeded();
private void setUpMapIfNeeded() {
// Do a null check to confirm that we have not already instantiated the
// map.
if (mMap == null) {
mMap = ((MapFragment) getFragmentManager().findFragmentById(
R.id.map)).getMap();
// Check if we were successful in obtaining the map.
if (mMap != null) {
// addMarkers
addMarkers();
addCameraOption();
}
}
}
private void addMarkers() {
//custom icon
Marker my_marker = mMap.addMarker(new MarkerOptions()
.position(MY_POINT).title("Melbourne")
.snippet("Some informaton: eg: Population: 4,137,400")
.icon(BitmapDescriptorFactory.fromResource(R.drawable.ic_launcher)));
//default icon
// Marker my_marker = mMap.addMarker(new MarkerOptions()
// .position(MY_POINT).title("Catalunya")
// .snippet("Some informaton: eg: Population: 4,137,400"));
private void addCameraOption(){
// Move the camera instantly to Sydney with a zoom of 15.
mMap.moveCamera(CameraUpdateFactory.newLatLngZoom(MY_POINT, 15));
// Zoom in, animating the camera.
mMap.animateCamera(CameraUpdateFactory.zoomIn());
// Zoom out to zoom level 10, animating with a duration of 2 seconds.
// mMap.animateCamera(CameraUpdateFactory.zoomTo(10), null, 2000);
// Construct a CameraPosition focusing on Mountain View and animate the camera to that
position.
CameraPosition cameraPosition = new CameraPosition.Builder()
.target(MY_POINT) // Sets the center of the map to Mountain View
.zoom(17) // Sets the zoom
.bearing(90) // Sets the orientation of the camera to east
.tilt(30) // Sets the tilt of the camera to 30 degrees
.build(); // Creates a CameraPosition from the builder
mMap.animateCamera(CameraUpdateFactory.newCameraPosition(cameraPosition));
}
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.hybrid:
mMap.setMapType(GoogleMap.MAP_TYPE_HYBRID);
break;
case R.id.terrain:
mMap.setMapType(GoogleMap.MAP_TYPE_TERRAIN);
break;
case R.id.none:
mMap.setMapType(GoogleMap.MAP_TYPE_NONE);
break;
case R.id.normal:
mMap.setMapType(GoogleMap.MAP_TYPE_NORMAL);
break;
case R.id.satellite:
mMap.setMapType(GoogleMap.MAP_TYPE_SATELLITE);
break;
default:
break;
}
}
activity_main.xml
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical" >
<!-- <fragment -->
<!-- android:name="com.example.maps.fragments.TopFragment" -->
<!-- android:layout_width="fill_parent" -->
<!-- android:layout_height="100dip" -->
<!-- android:tag="topFragment" /> -->
<LinearLayout
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:gravity="center_vertical"
android:weightSum="5" >
<Button
android:id="@+id/normal"
android:layout_width="0dip"
android:layout_height="wrap_content"
android:layout_weight="1"
android:text="Normal"
android:textSize="12sp" />
<Button
android:id="@+id/hybrid"
android:layout_width="0dip"
android:layout_height="wrap_content"
android:layout_weight="1"
android:text="Hybrid"
android:textSize="12sp" />
<Button
android:id="@+id/satellite"
android:layout_width="0dip"
android:layout_height="wrap_content"
android:layout_weight="1"
android:text="Satellite"
android:textSize="12sp" />
<Button
android:id="@+id/terrain"
android:layout_width="0dip"
android:layout_height="wrap_content"
android:layout_weight="1"
android:text="Terrain"
android:textSize="12sp" />
<Button
android:id="@+id/none"
android:layout_width="0dip"
android:layout_height="wrap_content"
android:layout_weight="1"
android:text="None"
android:textSize="12sp" />
</LinearLayout>
<fragment
android:id="@+id/map"
android:name="com.google.android.gms.maps.MapFragment"
android:layout_width="match_parent"
android:layout_height="0dip"
android:layout_weight="1" />
</LinearLayout>
Aquí tenéis una imagen del MapFragment con el marker personalizado, y con un zoom
personalizado de la camera:
http://www.aprendiendodeandroidymas.com/2012/12/comenzando-con-google-maps-api-v2-
parte.html
sábado, 1 de diciembre de 2012
Comenzando con Google Maps
Desarrollo sobre la plataforma Android
Hola a todos, nuevamente estoy por acá, esta vez voy a escribir sobre un
tema que realmente no me había puesto a utilizar en profundidad, pero que
debido a una aplicación que estoy armando, estoy leyendo bastante
documentación. Y es la utilización de los mapas de Google en nuestras
aplicaciones Android, asi que ahora vamos a arrancar con el mismo :D
Bueno si estan leyendo esto, imagino que ya tendrán instalado el IDE que
desean utilizar, en mi caso Eclipse, el SDK de Android y la JDK. Ya con
esto preparado y armado, para poder utilizar los mapas de Google, vamos a
necesitar un par de cosas más, una de ellas es con el SDK Manager
descargarse la versión de Android en la que queremos desarrollar, pero
que trae incorporada las API de Google, ya que con la versión original de
Android al no traer esto incorporado, no podremos utilizar los mapas, u
otros productos de Google.
Una vez que tengamos descargado esto, también lo que deberemos hacer es
crear una VM, con esa versión en particular de Android que trae
incorporadas esas API de Google.
Con esto solo no basta, el último paso para poder usar los mapas es
obtener una Key de Google Maps, esto no es muy complicado, este es el
manual oficial:
https://developers.google.com/maps/documentation/android/mapkey
Es muy sencillo obtenerla, lo que deberemos hacer es buscar la
debug.keystore (por las dudas aclaro, que si ustedes desean subir la app
a un repositorio como Google Play, deberán generar una nueva Key ya que
como podrán ver por el nombre esta es solo una versión para depuración y
si no lo hacen los que se bajen la app no podrán ver los mapas ), en el
caso de usuarios Linux normalmente esta se encuentra dentro de esta
carpeta: ~/.android/ de todas maneras si no conocemos la ubicación, una
forma muy sencilla de obtenerla es desde el Eclipse con el SDK
configurado, ir a Windows -> Preferences -> Android -> Build y como se ve
en la imagen, tenemos el path donde se encuentra dicho archivo.
Ahora se mueven a la carpeta donde se encuentra la key y con este
comando:
keytool -list -v -keystore debug.keystore ( la opción -v les muestra
todas las versiones como SHA1 y demás, yo la agregue al comando, porque a
veces te muestra un hash que a nosotros no nos sirve ;))
Podrán ver los diferentes hashes de la key, ustedes necesitan el MD5, que
debera ser similar a esto: Certificate fingerprint (MD5):
94:1E:43:49:87:73:BB:E6:A6:88:D7:20:F1:8E:B5:98 (que es el de ejemplo de
Google)
Ahora con este hash debemos dirigirnos a la siguiente dirección:
https://developers.google.com/android/maps-api-signup
Por supuesto que debemos aceptar los términos y condiciones, y aceptamos,
una vez realizado eso, como veremos en la siguiente imagen nos da unos
datos, yo les recomiendo copiarlos, porque los usaremos para poder
mostrar los mapas ;)
Se que diran, ufff que lio poder usar la API de Google Maps, pero como
ustedes van a ver una vez realizado esto, no va a ser complicado usarla,
y los beneficios para el uso de geolocalización es impresionante ;)
Así que lo que deberemos hacer ahora es crear un nuevo proyecto Android,
y le diremos que use para compilar el SDK con la API de Google, en este
caso yo quería usar Android 2.2 asi que lo configure con el API 8 pero
con la API de Google incorporada, como pueden ver en la imagen ;)
Una vez hecho esto, vamos a la carpeta res -> layout y allí vamos a
editar la vista principal del proyecto para agregarle el mapa, para eso
deberemos agregar el siguiente código:
<com.google.android.maps.MapView
android:id="@+id/mapageneral"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:apiKey="0rxZX0FYky7Lbpa9mz5h2Q_jSfup1flv9Fo7bEw"
android:enabled="true"
android:clickable="true"
/>
Donde el android:apiKey es la clave que les otorgó Google para su
debug.keystore.(también tengan en cuenta que si no le ponen el atributo
android:clickable en true, no podrán hacer nada con el mapa ;) ) Ahora lo
que nos queda es agregar las librería en el manifest, para ello dentro de
los tag application debemos insertar este código:
<uses-library android:name="com.google.android.maps" />
y también fuera del tag application, por convención antes del mismo
debemos agregar el permiso para el uso de internet, que se hace con el
siguiente código :
<uses-permission android:name="android.permission.INTERNET"/>
Ahora simplemente nos resta modificar un poco la clase Java que va a
manejar esa UI, para ello vamos a nuestra clase Mapas, y modificamos lo
siguiente:
hacemos que en vez de extender de Activity, que extienda de
MapActivity
dentro del método onCreate() agregamos el siguiente código:
// Con esto tomamos la referencia de nuestro mapa en la // vista
MapView mapageneral = (MapView)findViewById(R.id.mapageneral);
// Con esto hacemos que se vean los controles de //zoom del mapa
mapageneral.setBuiltInZoomControls(true);
// y con este ultimo hacemos que la vista de los
// mapas sean del tipo Street
mapageneral.setStreetView(true);
Bueno una vez hecho esto, podemos ver como funciona nuestra aplicación:
Documentación oficial:
Desarrollo:
http://developer.android.com/guide/topics/location/index.html
https://developers.google.com/maps/documentation/android/?hl=es
https://developers.google.com/maps/documentation/android/reference/index?hl=es
Bueno,esto es todo por ahora, hemos visto cómo insertar nuestro primer
mapa de Google en nuestra aplicación, espero que les alla gustado, nos
vemos en otra ocasión ;) y en la próxima seguramente estaremos ampliando
sobre el tema :D
sábado, 22 de diciembre de 2012
Comenzando con Google Maps API v2 parte 1
Desarrollo sobre la plataforma Android
Hola a todos nuevamente, en este post vamos a hablar de nuevo de Google
Maps en Android, pero esta vez, vamos a ver el uso de la API v2 de Google
Maps, ya que la versión 1 ya quedó deprecated :D , asi que vamos a tener
que volver a ver que vamos a necesitar, configurar el uso de la API y
después vamos a realizar un par de cosas que creo que nos van a resultar
bastante útil, como es, que nuestro mapa se ubique en la posicion donde
nos encontramos, y también como marcar algunos punto interesantes en el
mapa.
En esta ocasión además de utilizar la API de Google, también vamos a
utilizar un sistema de persistencia de datos, en este caso SQLite, el
motor de base de datos que trae por defecto Android. Si tiene alguna duda
con ello, pueden mirar esta serie de post:
http://www.aprendiendodeandroidymas.com/2012/04/persistencia-de-datos-con-sqlite-
sobre.html
Cualquier consulta,tratare de ayudarlos en lo que pueda :) así que ahora
comencemos con lo nuestro y cualquier cosa, realicen un comentario.
Antes que nada vamos a necesitar, instalar Google Play Service, ya que
para poder usar Google Maps ahora, es un poco diferente a la versión
anterior, así que con el SDK manager, la descargamos:
Después, al igual que en la anterior versión vamos a necesitar el hash de
nuestra key para firmar la app, pero esta vez en vez de MD5 va a ser el
SHA1, para eso en la terminal tipeamos el siguiente comando:
keytool -list -v -keystore ~/.android/debug.keystore
(por las dudas les recuerdo, que al igual que en la anterior versión de
la API, esta key solo sirve para el desarrollo, para que la app la puedan
subir a Google Play, deberán generar un nuevo certificado, todo esto esta
explicado en el anterior post ;)
Al ejecutar el comando, se debería ver una salida de consola, similar a
esta:
Una vez tenemos el hash de nuestro certificado, deberemos (a diferencia
de la anterior versión de la API) ir a nuestra Consola de Google API,
ingresando en la siguiente dirección:https://code.google.com/apis/console
Una vez que hayamos, ingresado, vamos arriba a la derecha, desplegamos el
panel y creamos un nuevo proyecto, con el nombre que nosotros deseemos.
Ahora deberás ir a la opción Service y activar la opción Google Maps
Android API v2 y aceptamos los términos de servicios ;)
Con estos pasos, ya no nos queda mucho para terminar de configurar el
proyecto, así que vamos directamente a obtener la KEY, vamos entonces
arriba a la derecha, seleccionamos API Access y hacemos click en create
new Android key.
En el formulario que nos aparece, deberemos poner el hash SHA1 que antes
obtuvimos, y además el nombre del package de nuestro proyecto separado
por un punto y coma, algo similar a esto:
22:74:RE:3E:7C:11:B2:07:46:EB:07:84:32:59:3C:6A:89:7E:16:96;com.aprendien
dodeandroid.rosario
Y luego de eso, obtendremos algo similar a esto:
Así que con esto ya tenemos la key necesaria para nuestro proyecto, como
en la anterior API, ahora esta key debemos agregarla a nuestro
AndroidManifest dentro de los tag <application> y </application>
<meta-data
android:name="com.google.android.maps.v2.API_KEY"
android:value="AkjnasASSGectCsZjY9JZEasdjnklnsdgIjJJJHgbbs"/>
Y debemos agregar los siguientes permisos:
<permission
android:name="com.aprendiendodeandroid.rosario.permission.MAPS_R
ECEIVE"
android:protectionLevel="signature"/>
<uses-permission
android:name="com.aprendiendodeandroid.rosario.permission.MAPS_RECEIVE"/>
Por supuesto que ustedes deberán colocar allí el nombre de su package
name, y reemplazar el mío ;) Una vez realizado esto, salvamos el
manifest, y tenemos todo configurado para usar la API.
Por las dudas les advierto, que esta API requiere, como minimo la version
de Android 2.2 y soporte para Open GL ES versión 2
Tambien les comento que estos son los permisos extra que recomienda la
gente de Google:
<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission
android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
<uses-permission
android:name="com.google.android.providers.gsf.permission.READ_GSERVICE
S"/>
<uses-permission
android:name="android.permission.ACCESS_COARSE_LOCATION"/>
<uses-permission
android:name="android.permission.ACCESS_FINE_LOCATION"/>
Aunque no es estrictamente necesario, y podemos usar solo los que
realmente necesitemos. Y también por el requerimiento que posee de Open
Gl, recomienda que agreguemos dentro de nuestro manifest:
<uses-feature
android:glEsVersion="0x00020000"
android:required="true"/>
Esto es bueno, porque si el smartphone no cumple con esta característica,
no le va a funcionar a la persona que instale la app, lo cual puede
provocar malos comentarios, lo que no es bueno para nuestra aplicaciòn :D
Ahora lo que deberemos hacer es simplemente configurar nuestro layout y
la clase que lo controla, si vamos a usar una versión de Android de la 3
en adelante simplemente la clase debe extender de Activity, pero si lo
queremos hacer con una versión anterior de Android, deberemos utilizar
las librerías de soporte. Si ese es el caso deberemos extender de ellas,
de la siguiente manera:
public class ClasePrincipal extends android.support.v4.app.FragmentActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
Esto se debe a que debemos utilizar en el layout, fragment, si ya no
debemos utilizar MapsActivitys ni nada parecido y en nuestro layout
deberemos colocar un código similar a este:
<?xml version="1.0" encoding="utf-8"?>
<fragment xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/map"
android:layout_width="match_parent"
android:layout_height="match_parent"
class="com.google.android.gms.maps.SupportMapFragment"/>
Donde solo lo que haremos es colocar un fragment, y especificar la clase
a la que corresponde.
Así que con eso, deberías poder ejecutar tu aplicación, y ver el mapa
correspondiente.
Aclaración: se me había olvidado de aclarar, para versiones de Android
anteriores a la 3 deben poseer entre las librerías de sus proyectos:
android-support-v4.jar
Ademas también deberemos poseer las librerías google-play-service.jar
y google-play-service_lib.jar
Estas dos ultimas librerías las obtenemos cuando con el sdk manager
descargarmos en los extras Google Play Services. Y las podemos incorporar
al proyecto, realizando click boton derecho, import..., Existing Android
Code Into Workspace, y allí nos movemos hasta la carpeta donde tenemos
instalado el SDK de Android “<carpeta-sdk-
android>/extras/google/google_play_services/libproject/google-play-
services_lib“.
Una vez hayamos importado esto, realizamos nuevamente click botón derecho
al proyecto, vamos a propiedades, a la sección Android, bajamos y
realizamos click en Add, nos va a agregar la ultima librería que acabamos
de agregar al proyecto, ya con esto no deberían tener problemas ;)
Código de ejemplo:
https://github.com/Android-Hispano/android-hispano-demo
Otros post relacionados con el tema:
http://www.aprendiendodeandroidymas.com/2012/12/comenzando-con-google-maps-api-v2-
parte_31.html
http://www.aprendiendodeandroidymas.com/2013/04/comenzando-con-google-maps-api-v2-
parte.html
Documentación oficial:
https://developers.google.com/maps/documentation/android/?hl=es
http://developer.android.com/guide/topics/location/index.html
https://developers.google.com/maps/documentation/android/?hl=es
https://developers.google.com/maps/documentation/android/reference/index?hl=es
Bueno,esto es todo por ahora, hemos visto cómo insertar nuestro primer
mapa de Google en nuestra aplicación utilizando la segunda versión de la
API, espero que les alla gustado, nos vemos en otra ocasión ;) y en la
próxima vamos a ver caracteristicas realmente útil, voy a ampliar mas
sobre el tema, pero el post ya me quedó demasiado extenso :D
lunes, 31 de diciembre de 2012
Comenzando con Google Maps API v2 parte 2
Desarrollo sobre la plataforma Android
Hola a todos, en este post vamos a hablar otra vez de Google Maps en
Android, pero esta vez, no vamos a hablar de un tema exclusivo de la API
v2 de Google Maps, ya que la versión 1 usa también estas estrategias para
manejar la localización ;)
En un principio puede resultarnos complicado, cosas simples como por
ejemplo obtener nuestra posición actual, algunas de las cosas que pueden
hacer que nos resulte complicado, pueden ser:
Muchas fuentes de información: aunque parezca extraño esto, el
tener múltiples fuentes de información (GPS, Wifi, 3G, Cell-ID), puede
ocasionarnos el problema de no saber cual usar, o de configurar uno y no
otro.
El cambio de posición: el saber como y cada cuanto se actualiza la
posición.
Consumos de datos y energía: como deben imaginar también tenemos
que tener en cuenta que de acuerdo a la manera en que tomemos estos
datos, van a variar los consumos de estas cosas :P
Por suerte la librería de Android nos va a ayudar bastante con este tema,
las dos cosas principales que vamos a necesitar van a ser dos objetos,
uno de tipo LocationManager y el otro un listener de tipo
LocationListener, un sencillo ejemplo podría ser:
// Tomamos la referencia hacia el manager
LocationManager locationManager = (LocationManager)
this.getSystemService(Context.LOCATION_SERVICE);
// Y aqui deberemos definir nuestro listener, para poder
// actualizar nuestra ubicacion
LocationListener locationListener = new LocationListener() {
public void onLocationChanged(Location location) {
// Este es el metodo que mas nos va a interesar implementar
// ya que es el que nos va a dar nuestra ubicacion
hacerUsoDeNuestraUbicacion(location);
}
// Estos otros metodos tambien deberiamos implementarlos
public void onStatusChanged(String provider, int status, Bundle
extras) {}
public void onProviderEnabled(String provider) {}
public void onProviderDisabled(String provider) {}
};
// Y aca registramos nuestro listener con el location manager, para
// poder ir tomando las actualizaciones de ubicacion
locationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER,
0, 0, locationListener);
Así que a nuestro manager deberemos pasarle, cual va a ser el proveedor
de ubicación, en este caso le pase NETWORK, pero tranquilamente podria
ser el GPS, tambien podriamos registrar los dos proveedores ;) los otros
dos parámetros que son números, van a manejar la frecuencia con la que se
va a ir actualizando. Hay que pensar en hacerlo dependiendo de nuestras
necesidades, porque podríamos hacerlo todo el tiempo, pero hay que tener
en cuenta el consumo de recursos y batería :P
Una vez visto esto, vamos a tener que tener en cuenta los permisos
necesarios en nuestra app, para que pueda utilizar la internet, gps o el
medio que usemos para tomar los datos. Ya que si esto no lo plasmamos en
el manifest, nos va a saltar un error al querer correr la aplicación.
Si van a utilizar la red y el GPS, van a necesitar agregar este permiso:
<uses-permission
android:name="android.permission.ACCESS_FINE_LOCATION" />
Ahora si solo van a usar la red, podrían usar este permiso:
<uses-permission
android:name="android.permission.ACCESS_COARSE_LOCATION" />
En el primer caso no se necesitan dos permiso, ya que
ACCESS_FINE_LOCATION contiene los dos permisos.
Como dije antes, hay que tener cuidado con el tema de los consumos, aquí
hay un gráfico del proceso para encontrar la ubicación:
Después de ver este gráfico, debemos pensar en cuando vamos a comenzar a
escuchar, para obtener actualizaciones de la ubicación. Así que para no
afectar los consumos, debemos ver si comenzamos a escuchar cuando arranca
la app, o cuando sucede algún tipo de acción, y ver cuando se va a
terminar la escucha. Hay que tener en cuenta el periodo de tiempo por el
que va a estar escuchando, ya que lo podríamos hacer por periodos, pero
tenemos que ver que esos periodos de tiempo sean lo suficientemente
largos para que el dispositivo pueda encontrar el dato.
Una cosa a tener en cuenta es algo que puede ser útil, pero a su vez puede causar dolores de
cabeza, la clase LocationManager tiene un método llamado getLastKnownLocation().Este método,
utiliza la caché de la última ubicación recibida, no devuelve la posición actual, tampoco solicita una
nueva posición al proveedor de localización, este método se limita a devolver la última posición que
se obtuvo a través del proveedor que se le indique como parámetro. Y esta posición se pudo
obtener hace pocos segundos, hace días, hace meses, o incluso nunca.Por eso hay que tener
cuidado cuando se usa, al querer usar la posición devuelta por el método getLastKnownLocation().
Volviendo al tema anterior, por eso debemos pensar bien cuando utilizar
requestLocationUpdates() para tomar los datos, y cuando
locationManager.removeUpdates(locationListener);
Para detener esa escucha del listener, y dejar así de consumir recursos.
Otro tip:
Para reducir los consumos, y así no tener quejas de las personas que utilizan la aplicación,
podría reducir la frecuencia con la que se actualiza la ubicación, seteando en el LocationProvider.
Y restringir a uno de todos los proveedores, GPS, NETWORK, también esto lo podemos
setear eligiendo que LocationProvider utilizamos.
Antes de dar un pequeño ejemplo funcional sobre toda esta teoría :D
queria comentarles, que con el emulador podemos similar el uso de GPS, es
más para algunas cosas de este tipo, puede llegar a ser más útil, que un
movil físico, ya que con archivos KML podremos simular recorridos:
https://developers.google.com/kml/documentation/kml_tut?hl=es
public class NuestraUbicacion extends Activity implements LocationListener {
// En la activity deberiamos creear los textview
private TextView latituteText;
private TextView longitudeText;
private LocationManager locationManager;
private String proveedor;
/** En este caso implementamos directamente en la clase el LocationListener y heredamos de
Activity */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
// tomamos la refencia de los textview
latituteText = (TextView) findViewById(R.id.TextView1);
longitudeText = (TextView) findViewById(R.id.TextView2);
// Tomamos el location manager
locationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
// Definimos un objeto del tipo criteria para que este elija cual locatioin provider nos
// conviene utilizar
Criteria criteria = new Criteria();
proveedor = locationManager.getBestProvider(criteria, false);
Location ubicacion = locationManager.getLastKnownLocation(proveedor);
// vemos si se inicializamos la ubicacion
if (location != null) {
System.out.println("Proveedor " + proveedor + " ha sido seleccionado.");
onLocationChanged(ubicacion);
} else {
latituteText.setText("Ubicacion no encontrada");
longitudeText.setText("Ubicacion no encontrada");
}
}
/* actualizamos la ubicacion */
@Override
protected void onResume() {
super.onResume();
locationManager.requestLocationUpdates(proveedor, 400, 1, this);
}
/* detenemos el listener */
@Override
protected void onPause() {
super.onPause();
locationManager.removeUpdates(this);
}
@Override
public void onLocationChanged(Location location) {
int lat = (int) (location.getLatitude());
int lng = (int) (location.getLongitude());
latituteText.setText(String.valueOf(lat));
longitudeText.setText(String.valueOf(lng));
}
@Override
public void onStatusChanged(String provider, int status, Bundle extras) {
// metodo a sobreescribit del LocationListener
}
// lanzamos un toast cuando es habilitado el proveedor
@Override
public void onProviderEnabled(String provider) {
Toast.makeText(this, "Habilitado el nuevo proveedor " + proveedor,
Toast.LENGTH_SHORT).show();
}
// lanzamos un toast cuando es deshabilitado el proveedor
@Override
public void onProviderDisabled(String provider) {
Toast.makeText(this, "Disabled provider " + provider,
Toast.LENGTH_SHORT).show();
}
}
Código de ejemplo:
https://github.com/Android-Hispano/android-hispano-demo
Otros post relacionados con el tema:
http://www.aprendiendodeandroidymas.com/2012/12/comenzando-con-google-maps-api-v2-
parte.html
http://www.aprendiendodeandroidymas.com/2013/04/comenzando-con-google-maps-api-v2-
parte.html
Documentación oficial:
http://developer.android.com/guide/topics/location/strategies.html
https://developers.google.com/maps/documentation/android/?hl=es
http://developer.android.com/guide/topics/location/index.html
https://developers.google.com/maps/documentation/android/?hl=es
https://developers.google.com/maps/documentation/android/reference/index?hl=es
Es todo por ahora, vimos cómo obtener nuestra localización, y utilizar
los diferentes medios para el posicionamiento. En el próximo post,
probablemente veamos, como agregar marcadores, y algunas cosas para dejar
más vistoso nuestro mapa. Espero que les haya gustado :D
miércoles, 10 de abril de 2013
Comenzando con Google Maps API v2 parte 3
Desarrollo sobre la plataforma Android
Hola como estas todos, en esta ocasión vamos a continuar con la última versión de la API
de Google Maps para Android, en este caso vamos a ver como modificamos la forma en la
que se ve el mapa como el zoom , o el ángulo del mismo. Estaba pensando seguir con el
tema de la ubicación, pero lo voy a dejar para la siguiente, así posteriormente vamos a situar
puntos varios puntos en el mapa. Pero prefiero que primero sepamos manejar la vista, para
ello simplemente vamos a mover la cámara ;)
Con esta nueva versión de la API vamos a poder rotar, acercar o correr el mapa de manera
sencilla solo con algunos gestos, lo que va a hacer que para el usuario pueda ubicar de
mejor manera de una forma en la que le parezca mas cómodo ademas muchas ciudades ya
tienen un mapa en 3d lo que lo hace realmente atractivo.
Lo bueno de mover solo la “ cámara” es que esto no va a modificar ningún overlay,
marcador, o imagen que nosotros hayamos ubicado sobre el mapa, así solo se cambiara la
vista del mapa, sin afectar lo que le agreguemos. Vamos a ver un par de conceptos
necesarios, para entender el cómo modificar la vista.
De la misma manera que Google Maps para la web, la version de Android representan al
mundo que es esférico de manera plana en nuestros dispositivos utilizando
la proyección de Mercator:
http://es.wikipedia.org/wiki/Proyecci%C3%B3n_de_Mercator
Así que si nos movemos para el este como para el oeste se va a ir repitiendo el mapa, no así
como para el norte o sur, donde sí tienen límite. (estos límites son aproximadamente +/- 85
grados, lo que nos va a ayudar a facilitarnos la lógica para la selección de los tile )
La posición de la cámara:
El mapa fue modelado como si se lo estuviera mirando con una cámara hacia el piso, para
modificar la forma en que la cámara observa y muestra este mapa, vamos a tener que
modificar algunas de estas propiedades:
Target (Ubicación) : Este va a ser la ubicación del centro del mapa, esta la vamos a
especificar, pasándole la longitud y latitud del mismo.
Zoom: Imagino que deben saber a que se refiere esta propiedad ;) básicamente el nivel de
zoom, es el que va a determinar la escala del mapa, mientras más grande el zoom más
detallada y cercana la imagen del mapa, mientras menor el zoom o sea más cercano a 0, nos
acercamos más a ver el planeta completo. Aumentando en uno vamos a doblar el tamaño de
la imagen (debemos tener en cuenta que no necesariamente debe ser un entero el zoom)
Bearing (orientación)
Es la dirección en que la línea vertical apunta, esta se mide en grados desde el norte.
Básicamente nos va a servir para poder girar la manera en la que vemos el mapa, por
ejemplo si le seteamos un bearing de 90 grados, el mapa nos va a quedar apuntando hacia
el este.
Tilt (angulo en el que vemos el mapa)
Es la posición de la cámara, que se encuentra en un arco que está ubicado entre la
superficie de la tierra y la posición central del mapa, esta posición se mide en grados, así
que cuando modificamos los grados, lo que vemos es una perspectiva diferente del mapa.
Ejemplo, con cero grados, el punto 1 es la cámara y el 2 es el mapa actual:
Así es como se ve el mapa:
Los grados pueden ir de cero a 90, veamos un ejemplo con 45 grados, ahora el número 3
representa la cámara así que ahora la línea que va hasta el número 4 forma la vista que se
verá del mapa:
Ahora veamos como se ve esto: (tengan encuentra que la posición es exactamente la misma
que la anterior, el mapa se ve diferente solo porque cambio el punto de vista, no el mapa en
si)
Para no hacerlo demasiado largo, voy a comentar un par de cosas más, pero no
profundizaré en el tema, para eso creo que la docu oficial esta muy bien explicada, y los
temas anteriormente tratados son los mas importante.
Algo que me pareció bastante agradable es la manera en la que podemos animar la forma en
que se mueve la posición de la cámara, podemos hacer que se mueve de forma
mas rápida o lenta, modificar el zoom cuando se mueve, etc para ello nos brindan por
ejemplo los objetos CameraUpdate y CameraUpdateFactory (les recomiendo jugar con
ellos ;) )
Esto es un ejemplo de como usar lo anteriormente comentado:
private static final LatLng SYDNEY = new LatLng(-33.88,151.21);
private static final LatLng MOUNTAIN_VIEW = new LatLng(37.4, -122.1);
private GoogleMap map;
... // con map debemos obtener referencia a nuestro MapFragment o MapView
// mover la camara instantaneamente a Sydney con un zoom 15.
map.moveCamera(CameraUpdateFactory.newLatLngZoom(SYDNEY, 15));
// agrandamos el zoom en 1,animando la camara
map.animateCamera(CameraUpdateFactory.zoomIn());
// alejamos el zoom al nivel 10, animando la cámara por 2 segundos
map.animateCamera(CameraUpdateFactory.zoomTo(10), null, 2000);
// Construimos una camara que apunta a Mountain View y animamos la camara hasta esa //
posicion
CameraPosition cameraPosition = new CameraPosition.Builder()
.target(MOUNTAIN_VIEW) // seteamos el centro del mapa a Mountain View
.zoom(17) // configuramos el zoom
.bearing(90) // cambiamos la orientación de la cámara al este
.tilt(30) // configuramos el angulo de la cámara a 30 grados
.build(); // Creamos la CameraPosition
map.animateCamera(CameraUpdateFactory.newCameraPosition(cameraPosition));
Documentación oficial:
https://developers.google.com/maps/documentation/android/views
Otros post relacionados con el tema:
http://www.aprendiendodeandroidymas.com/2012/12/comenzando-con-google-maps-api-v2-
parte.html
http://www.aprendiendodeandroidymas.com/2012/12/comenzando-con-google-maps-api-v2-
parte_31.html
Código fuente:
https://github.com/Android-Hispano/android-hispano-demo
Espero que les haya sido de utilidad el tema, creo que con esto tenemos para jugar un buen
rato con nuestro mapa, realmente me resulto bastante sencillo, y agradable el manejo de la
vista, nos vemos en una próxima entrega.
