Aplicación de Camping en Costa Rica

Aplicación de Camping en Costa Rica

Integrantes

Boris Andrey Altamirano Chinchilla B30255
José Pablo Ávila López B30724
Alexander Jose Reyes Morales B25517

Descripción

Este proyecto consiste en diseñar una aplicación para celulares que funcionen con el sistema operativo Android, la cual permitirá al usuario conocer acerca de lugares para acampar en Costa Rica, con las facilidades de ubicación GPS, información del lugar como precio, vacantes, calificación dirección y demás características pertinentes al sitio. Además de la posibilidad de agregar un nuevo sitio de camping o búsqueda de uno ya existente en la base de datos.

Objetivo Genereral

Desarrollar una aplicación para dispositivos Android que permita al usuario ubicar, calificar o anunciar lugares de camping en Costa Rica, dicha aplicación tiene como fin brindar al usuario una forma sencilla de explorar dichos lugares de la manera que más le sea conveniente, ya sea por ubicación GPS, búsquedas por zona geográfica y/o búsquedas de acuerdo a un rango de precios o diferentes filtros.

Objetivos Específicos

1. Diseñar un servidor en python que almacene y transmita la información solicitada por el usuario (cliente) a través de una conexión de internet.

2. Diseñar una aplicación para celular en java que permita buscar lugares para acampar y agregar nuevos lugares accediendo a una base de datos y que los usuarios puedan calificar dichos lugares.

3. Implementar a la aplicación el uso de GPS para que sea más amigable con los usuarios y permita realizar búsquedas personalizadas utilizando la ubicación de cada usuario.

Implementacion: Base de datos y Servidor

Construccion de la Base de Datos:
Con la necesidad de implementar una base de datos para contener la información que brindará la aplicación se procedio a la construcción de la misma, para ello se utílizo MySQL (My Structured Query Language) asi como el modulo Python-MySQLdb.

#!/usr/bin/python
import MySQLdb
db = MySQLdb.connect("localhost", "bdd", "bdd123", "Base_de_Datos")
cursor = db.cursor()

Por lo tanto la DB se conforma por las siguientes tablas:

Usuarios: Esta tabla registra la informacion de cada usuario, es decir, nombre de usuario, contraseña, nombre y correo electronico.

c1 = """CREATE TABLE Usuarios( 
            username VARCHAR(30) NOT NULL,
            password VARCHAR(20) NOT NULL,
            name VARCHAR(125),
            email VARCHAR(125) NOT NULL,
            PRIMARY KEY(username));"""
cursor.execute(c1)

Camping: Esta tabla contiene la informacion referente a los lugares de camping resgistrados en la aplicacion.

c2 = "CREATE TABLE Camping("
c2 +=     "ID INT(5) AUTO_INCREMENT,"
c2 +=     "name VARCHAR(125) NOT NULL,"
c2 +=     "city VARCHAR(30) NOT NULL,"
c2 +=     "location VARCHAR(125) NOT NULL,"
c2 +=     "phone VARCHAR(50) NOT NULL,"
c2 +=     "email VARCHAR(125),"
c2 +=     "price INT(5),"
c2 +=     "latitude double,"
c2 +=     "longitude double,"
c2 +=     "PRIMARY KEY(ID));"
cursor.execute(c2)

Comentarios: Por ultimo esta tabla guardara los comentarios o review asi como la puntuacion dada por los usuarios a los distintos lugares de camping registrados.

c3 = "CREATE TABLE Comentarios("
c3 +=     "ID INT(5) NOT NULL AUTO_INCREMENT,"
c3 +=     "campname VARCHAR(125) NOT NULL,"
c3 +=     "username VARCHAR(30) NOT NULL,"
c3 +=     "date DATE NOT NULL,"
c3 +=     "comment VARCHAR(300) NOT NULL,"
c3 +=     "score INT(1) NOT NULL,"
c3 +=     "PRIMARY KEY(ID));"
cursor.execute(c3)
db.close()

Para el uso de la informacion contenida en las tablas se implemento en Python el siguiente codigo:

Opciones_BdD.py

#!/usr/bin/python
 
import MySQLdb
 
db = MySQLdb.connect("localhost", "bdd", "bdd123", "Base_de_Datos")
cursor = db.cursor()
 
#Se encarga de agregar los datos de los usuarios en la tabla Usuarios de la DB.       
def add_user(U,P,N,E):
    try:
       command = "INSERT INTO Usuarios(username,password,name,email)"
       command += "VALUES ('%s','%s','%s','%s');" % (U,P,N,E)
       result = cursor.execute(command)
       db.commit()
    except: result = 0
    return(result)
 
#Retorna la contraseña del usuario (uso interno)
def get_password(U):
    cursor.execute("SELECT password FROM Usuarios WHERE username = '%s';" % U)
    return cursor.fetchone()[0]
 
#Se encarga de eliminar los registros de los usuarios que asi lo deseen
def delete_user(U):
    cursor.execute("DELETE FROM Usuarios WHERE (username = %s);" % U)
 
#Se encarga de agregar los datos de los lugares de camping en la tabla Camping de la DB. 
def add_camping(N,P,L,T,E,RP,La,Lg):
    try:
       command = "INSERT INTO Camping(name,city,location,phone,email,price,latitude,longitude)"
       command += "VALUES ('%s','%s','%s','%s','%s','%d','%s','%s');" % (N,P,L,T,E,RP,La,Lg)
       result = cursor.execute(command)
       db.commit()
    except: result = 0
    return(result)
 
#Retorna los lugares de camping que coincidan con el nombre buscado por el usuario.
def search_name(N):
    cursor.execute("SELECT * FROM Camping WHERE name = '%s';" % N)
    return(cursor.fetchall())
 
#Retorna los lugares de camping que se ubiquen en la provincia solicitada por el usuario.
def search_city(P):
    cursor.execute("SELECT * FROM Camping WHERE city = '%s';" % P)
    return(cursor.fetchall())
 
#Retorna los lugares de camping con precio menor o igual al indicado por el usuario.
def search_price(RP):
    cursor.execute("SELECT * FROM Camping WHERE price <= '%d';" % RP)
    return(cursor.fetchall())
 
#Es una combinacion de los 2 metodos anteriores.
def search_cityprice(P,RP):
    cursor.execute("SELECT * FROM Camping WHERE city = '%s' AND price <= '%d';" % (P, RP))
    return(cursor.fetchall())
 
#Se encarga de agregar los datos necesarios en la tabla Comentarios.
def add_comment(NC,U,D,C,S):
    try:
       command = "INSERT INTO Comentarios(campname,username,date,comment,score)"
       command += "VALUES ('%s','%s','%s','%s','%s');" % (NC,U,D,C,S)
       result = cursor.execute(command)
       db.commit()
    except: result = 0
    return(result)

Implementacion del Servidor:

Servidor.py

Se encarga de establecer el Servidor Online; utiliza un 'import' de la clase Cliente_Servidor.py de la cual utiliza el metodo 'decide'.

#! /usr/bin/env python
 
import socket, os
import Cliente_Servidor
from Cliente_Servidor import C_S
 
def socket_setup():
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_address = ('localhost', 10100)
    server.bind(server_address)
    server.listen(1)
    print "Server created and configured"
    return server
 
def wait_connection(server):
    wait_connection = True
    while wait_connection:
          print "Online and waiting for new requests"
          client_socket, client_address = server.accept()
          newproc = os.fork()
          if (newproc == 0):
             wait_connection = False
             Cliente_Servidor = C_S(client_socket)
             Cliente_Servidor.decide()
             Cliente_Servidor = None
             print 'lost connection'
             os._exit(1)
 
def main():
    server = socket_setup()
    wait_connection(server)
 
if __name__== "__main__":
   main()

Cliente_Servidor.py

Contiene los metodos necesarios para el funcionamiento del Servidor, para ello utiliza un 'import' de la clase Opciones_BdD.py.

#! /usr/bin/env python
 
import socket
import Opciones_BdD as obd
 
class C_S:
      def __init__(self, client_socket):
          self.client_socket = client_socket
          self.username = ""
 
      def __del__(self):
          del self.client_socket
 
#El metodo 'decide' se encarga de utilizar los metodos del archivo Opciones_BdD.py 
      def decide(self):
          self.client_socket.settimeout(900)
          while True:
                try:
                   #Se asigna a msg la informacion recibida desde el cliente.
                   msg = self.client_socket.recv(4096)
                except socket.timeout:
                       self.client_socket.close()
                       break
                instruction = []
                instruction = msg.split('<>')#Se encarga de transformar la informacion 
                                             #contenida en msg(un String) en una lista mediante el metodo split.
                command = instruction[0]
                #Segun el comando se llama al metodo correspondiente los cuales se describen a continuacion.
                if (command == 'printf'):
                   self.printf(instruction)
                elif (command == 'signup'):
                     self.SignUp(instruction)
                elif (command == 'login'):
                     self.Login(instruction)
                elif (command == 'logout'):
                     self.Logout()
                elif (command == 'closeaccount'):
                     self.DeleteAccount(instruction)
                elif (command == 'addcamping'):
                     self.AddCamping(instruction)
                elif (command == 'sname'):
                     self.SearchByName(instruction)
                elif (command == 'scity'):
                     self.SearchByCity(instruction)
                elif (command == 'sprice'):
                     self.SearchByPrice(instruction)
                elif (command == 'scity-price'):
                     self.SearchByCity_Price(instruction)
                elif (command == 'comment'):
                     self.AddComment(instruction)
 
      #Retorna al cliente una respuesta predefinida segun el caso.
      def answer(self, answer):
          self.client_socket.sendall(answer)
 
      def printf(self, msg_list):
          print msg_list[1]
          self.answer("Success")
 
      #Llama al metodo add_user de obd y le asigna los valores necesarios segun el orden de la lista.
      def SignUp(self, msg_list):
          estado = obd.add_user(msg_list[1], msg_list[2], msg_list[3],msg_list[4])
          if estado:
             self.username = msg_list[1]
             self.answer("Cuenta Creada<>Bienvenido")
          else:
             self.answer("ERROR<>El Nombre de Usuario YA exite.")
 
      #Llama al metodo add_user de obd y le asigna los valores necesarios segun el orden de la lista.
      def Login(self, msg_list):
          if msg_list[2] == obd.get_password(msg_list[1]):
             self.answer("Inicio de sesion<>Exitoso")
             self.username = msg_list[1]
          else:
             self.answer("ERROR:<>Nombre de Usuario y/o Password invalidos")
 
      #Asigna un valor nulo al username de esta clase.
      def Logout(self):
          self.username = ""
          self.answer("Hasta Luego")
 
      #Verifica que la contraseña dada por el usuario, el cual ya inicio sesion, coincida con la del
      #registro; de ser asi llama al metodo delete_user de obd.
      def DeleteAccount(self, msg_list):
          if msg_list[1] == obd.get_password(self.username):
             obd.delete_user(self.username)
             self.username = ""
             self.answer("Cuenta Eliminada")
          else:
             self.answer("ERROR:<>El Password  no concuerda.")
 
      #Llama al metodo add_user de obd y le asigna los valores necesarios segun el orden de la lista.
      def AddCamping(self, msg_list):
          estado = obd.add_camping(msg_list[1],msg_list[2],msg_list[3],msg_list[4],msg_list[5],msg_list[6],msg_list[7],msg_l$
          if estado:
             self.answer("Exito<>Establecimiento Agregado")
          else:
             self.answer("ERROR:<>El nombre ya exite")
      #Utiliza el metodo add_comment de obd asignando los parametros recibidos desde el cliente.
      def AddComment(self, msg_list):
          estado = obd.add_comment(msg_list[1],self.username,msg_list[2],msg_list[3], msg_list[4])
          if estado:
             self.answer("Exito<>Su comentario ha sido agregado")
          else:
             self.answer("ERROR:<>Su comentario no se pudo agregar.")
 
      #Asigna el parametro necesario al metodo search_name de obd y retorna la informacion recibida desde
      #la base de datos hacia el cliente.
      def SearchByName(self, msg_list):
          lists = obd.search_name(msg_list[1])
          data = ''
          i = 0
          while i < len(lists):
                data += lists[i][0]
                if (i!=(len(lists)-1)):
                   data += '%/'
                i += 1
          message = "Resultado<>"+data
          self.answer(message)
 
      #Asigna el parametro necesario al metodo search_city de obd y retorna la informacion recibida desde
      #la base de datos hacia el cliente.
      def SearchByCity(self, msg_list):
      lists = obd.search_city(msg_list[1])
          data = ''
          i = 0
          while i < len(lists):
                data += lists[i][0]
                if (i!=(len(lists)-1)):
                   data += '%/'
                i += 1
          message = "Resultado<>"+data
          self.answer(message)
 
      #Asigna el parametro necesario al metodo search_price de obd y retorna la informacion recibida desde
      #la base de datos hacia el cliente.
      def SearchByPrice(self, msg_list):
          lists = obd.search_price(msg_list[1])
          data = ''
          i = 0
          while i < len(lists):
                data += lists[i][0]
                if (i!=(len(lists)-1)):
                   data += '%/'
                i += 1
          message = "Resultado<>"+data
          self.answer(message)
 
      #Asigna los parametros necesarios al metodo search_cityprice de obd y retorna la informacion
      #recibida desde la base de datos hacia el cliente.
      def SearchByCity_Price(self, msg_list):
          lists = obd.search_cityprice(msg_list[1], msg_list[2])
          data = ''
          i = 0
          while i < len(lists):
                data += lists[i][0]
                if (i!=(len(lists)-1)):
                   data += '%/'
                i += 1
          message = "Resultado<>"+data
          self.answer(message)

Cliente.py

Se encarga de establecer una conexion con el Servidor Online ademas de asegurar que la informacion proporcionada por el usuario tenga el formato correcto para el buen funcionamiento del servidor.

#!/usr/bin/env python
 
import socket
 
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_address = ('localhost', 10100)
print "socket created"
client.connect(server_address)
print "connection established, write a command"
 
def ask_info():
        info = raw_input()
        return info
        print '/n'
 
wait = True;
while wait:
         command = ask_info()
         if (command == "exit"):
            wait = False
 
         elif (command == 'print'):
              info = ask_info()
              message = 'printf<>'+info
              client.sendall(message)
              print client.recv(100)
 
         elif (command == "signup"):
              tmplist = ['username', 'password', 'name', 'email']
              j = 0
              for i in tmplist:
                  print i,
                  tmplist[j] = ask_info()
                  j += 1
              info = reduce(lambda x,y: x+'<>'+y, tmplist)
              message = command+'<>'+info
              client.sendall(message)
              print client.recv(100)
 
         elif (command == "login"):
              tmplist = ['username', 'password']
              j = 0
              for i in tmplist:
                  print i,
                  tmplist[j] = ask_info()
                  j += 1
              info = reduce(lambda x,y: x+'<>'+y, tmplist)
              message = command+'<>'+info
              client.sendall(message)
              print client.recv(100)
 
         elif (command == "logout"):
              client.sendall(command)
              print client.recv(100)
 
         elif (command == "closeaccount"):
              tmplist = ['password']
              j = 0
              for i in tmplist:
                  print i,
                  tmplist[j] = ask_info()
                  j += 1
              info = reduce(lambda x,y: x+'<>'+y, tmplist)
              message = command+'<>'+info
              client.sendall(message)
              print client.recv(100)
 
         elif (command == "addcamping"):
              tmplist = ['name', 'city', 'location', 'phone', 'email', 'price', 'latitude', 'longitude']
              j = 0
              for i in tmplist:
                  print i,
                  tmplist[j] = ask_info()
                  j += 1
              info = reduce(lambda x,y: x+'<>'+y, tmplist)
              message = command+'<>'+info
              client.sendall(message)
              print client.recv(100)
 
         elif (command == "sname"):
              tmplist = ['Name of Interest']
              j = 0
              for i in tmplist:
                  print i,
                  tmplist[j] = ask_info()
                  j += 1
              info = reduce(lambda x,y: x+'<>'+y, tmplist)
              message = command+'<>'+info
              client.sendall(message)
              print client.recv(100)
 
         elif (command == "scity"):
              tmplist = ['City of Interest']
              j = 0
              for i in tmplist:
                  print i,
                  tmplist[j] = ask_info()
                  j += 1
              info = reduce(lambda x,y: x+'<>'+y, tmplist)
              message = command+'<>'+info
              client.sendall(message)
              print client.recv(100)
 
         elif (command == "sprice"):
              tmplist = ['Price of Interest']
              j = 0
              for i in tmplist:
                  print i,
                  tmplist[j] = ask_info()
                  j += 1
              info = reduce(lambda x,y: x+'<>'+y, tmplist)
              message = command+'<>'+info
              client.sendall(message)
              print client.recv(100)
 
         elif (command == "scity-price"):
              tmplist = ['City of Interest', 'Pice of Interest']
              j = 0
              for i in tmplist:
                  print i,
                  tmplist[j] = ask_info()
                  j += 1
              info = reduce(lambda x,y: x+'<>'+y, tmplist)
              message = command+'<>'+info
              client.sendall(message)
              print client.recv(100)
 
         elif (command == "comment"):
              tmplist = ['campname', 'date', 'comment', 'score']
              j = 0
              for i in tmplist:
                  print i,
                  tmplist[j] = ask_info()
                  j += 1
              info = reduce(lambda x,y: x+'<>'+y, tmplist)
              message = command+'<>'+info
              client.sendall(message)
              print client.recv(100)

Diseño de la aplicación Java

(Pablo Ávila) Para la interfaz gráfica, la cual corresponde a una serie de pantallas conectadas entre sí por botones y diferentes condiciones que se explicaran más adelante se realizó el siguiente diagrama, para representar el formato que tendrá la aplicación:

Ahora se explicará de una forma general el funcionamiento de la interfaz tomando como apoyo el diagrama en el cual se muestra a qué pantalla o qué función desempeña cada botón.
De acuerdo con dicho diagrama, a la pantalla 1 (Log in) se le impusieron las condiciones que ambos espacios deben de estar rellenados y además que la contraseña coincida con el usuario. En caso de que el usuario ya existe, le envía un mensaje de error.
En la segunda pantalla (Sign Up), deben estar las cuatro cajas de texto completas, para de esta forma obtener la información necesaria para crear un nuevo usuario. Por otro lado, no se puede introducir un nombre de usuario ya existente en “User name”, si se hace, se muestra un mensaje puntualizando el error. Y como es debido, lo que se introduce como contraseña debe ser escrito de igual manera en “Confirm Password”.
Si estas condiciones se cumplen, se guarda el nuevo usuario y se pasa a la siguiente pantalla.
Si en “Menú” se elige “Go to map” nos envía al mapa con localización GPS que está más detallada en el siguiente apartado.
En el caso de buscar el camping place por un filtro se agregaron los filtros por nombre, localización, rango de precios o calificación. Esto nos ramifica a dos opciones:
La primera es si se selecciona alguno de los primeros dos elementos y no se encuentra un establecimiento con esas descripciones se le envía a elegir si quiere agregarlo a la base de datos. Si el usuario lo va a agregar lo hace en la pantalla “Add it” donde, como mínimo debe rellenar los espacios de: “Name”,“Location”,“Price” y “Description”, para guardar dicho establecimiento en la base de datos.
La segunda opción es el cuando sí encuentra el parámetro digitado, así se mostrará una lista de todos los establecimientos que posean la característica digitada, al elegir uno de ellos se desplegará una nueva pantalla con la información del camping place y además un botón de hyperlink a su pagina en Facebook (u otra red social según convenga).

Para la creación de los distintos botones, cajas de texto y demás elementos utilizados en la aplicación se utilizaron los lenguajes de XML para la visualización gráfica y Java para la programación del funcionamiento de cada elemento.

Para cada nombre que recibirá un elemento visible debe crearse una nueva hilera, para lo que se va a la carpeta del proyecto, luego seleccionar “res”, “values” y por último “strings.xml” y se crea una nueva string con el nombre y el valor (hilera gráfica).

En la creación en XML de los elementos se utilizó lo siguiente:
Botón:

<Button
android:id="@+id/id del botón"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginTop="margen verticaldp"
android:layout_marginStart="margen horizontaldp"
android:text="@string/nombre del string" />

Luego para los textos editables, los textos visibles y spinners es el mismo código pero se cambia la forma de abrir (<Button), por un <EditText, ó un <TextView ó un <Spinner respectivamente. Este último no necesita las últimas dos líneas del código, pero por otro lado se debe abrir un nuevo proyecto xml que contenga:

<resources>
            <string-array name= "nombre del spinner">
            <item >primer item</item>
            <item >segundo</item>
              ...
        </string-array>
</resources>

Una vez que los elementos ya fueron creados de manera gráfica hay que proceder a brindarles una función. Para esta aplicación se necesitaron básicamente para abrir una nueva actividad (pantalla), que desplieguen mensajes de aviso, de hyperlink, cajas de texto visibles y editables.
Cada elemento se debe crear una instancia con el tipo de variable,en el paquete y la clase correspondiente. Además se debe importar el tipo de variable, este es el mismo que se utilizó en el xml. Luego inicializarla en el método OnCreate. Por ejemplo para un botón:

 package com.example."paquete";

import android.widget.Button;

public class "Clase" extends ActionBarActivity {
	Button "nombre";

	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_search);
		
		"nombre" = (Button) findViewById(R.id."id del boton en el xml");

De igual forma para todos los tipos de variables necesarias.
Si se quiere un botón que lo envíe a otra actividad debe crearse antes la segunda actividad. Para esto se crea un nuevo “Android Activity”. Después hay que importar otras librerías como “Intent” y “View” programar el botón de la siguiente forma:

"nombre".setOnClickListener(new View.OnClickListener() {
	 public void onClick(View v) {
	       startActivity(new Intent("Actividad actual".this, "Siguiente".class));
      }
	 });

Para un botón de hypervínculo se cambian la acción por las siguientes líneas:

 Intent intent = new Intent(Intent.ACTION_VIEW,Uri.parse("dirección electrónica"));
startActivity(intent);

Para desplegar un mensaje simplemente se escribe la siguiente línea en el método anterior o dentro de un botón para que se despliegue al presionarlo:

 Toast.makeText("Actividad".this, "Mensaje", Toast.LENGTH_LONG).show();

Para obtener el texto escrito en una caja de texto, o añadir un mensaje a un texto visible respectivamente se utiliza lo siguiente dentro del método “OnCreate” o dentro de un botón:

String type= "Nombre texto editable".getText().toString().toLowerCase();	
"nombre texto visible".setText("mensaje");

Por último, tanto para un spinner como para una lista se puede obtener cada item mediante su posición comenzando de cero para la primera; o al darle click sobre él. Y para que funcione debe crearse una clase nueva, similar a esto:

 ArrayAdapter<CharSequence> ar= ArrayAdapter.createFromResource(this, R.array."nombre del spinner", android.R.layout.simple_list_item_1);
ar.setDropDownViewResource(android.R.layout.simple_dropdown_item_1line);
sp.setAdapter(ar);
sp.setOnItemSelectedListener(new "nueva clase"());
	
            public class function implements OnItemSelectedListener {
		@Override
		public void onItemSelected(AdapterView<?> parent, View view,
				int pos, long id) {
                  //Acá van las funciones al selecionar los items como se mencionó anteriormente
	        }

		@Override
		public void onNothingSelected(AdapterView<?> parent) {
		}
	    }

Para darle una apariencia más atractiva a la aplicación se puede modificar el tema “theme”. Para esto en la vista gráfica del la cada actividad

Todo este paradigma fue creado en “Eclipse” y probado en un emulador de celular, el cual traía el paquete de ADT descargado (ver anexos).

Implementación de Open Street Maps y ubicación por GPS

(Boris Altamirano)

Primero se deben descargar las siguientes dos librerías:
osmdroid-android-3.0.8.jar
slf4j-android-1.5.8.jar

Una vez descargadas, se deben agregar estas librerías al directorio libs del proyecto en eclipse, para ello se hace lo siguiente. Copiar los dos archivos descargados en la carpeta libs. En el software eclipse, ir a la viñeta proyecto → Propiedades → Java Build Path → Click en Add JARs y seleccionar las librerías descargadas.

Luego se debe modificar el archivo manifest, agregando los siguientes permisos a la aplicación:

android.permission.ACCESS_COARSE_LOCATION
android.permission.ACCESS_FINE_LOCATION
android.permission.ACCESS_WIFI_STATE
android.permission.ACCESS_NETWORK_STATE
android.permission.INTERNET
android.permission.WRITE_EXTERNAL_STORAGE

También se debe agregar el siguiente código en el main layout (generalmente llamado activity_main.xml), esto permite la visualización gráfica del mapa en pantalla:

<org.osmdroid.views.MapView
        android:id="@+id/mapView"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_alignParentLeft="true"
        android:layout_alignParentRight="true"/>

Ahora se procede a importar las librerias necesarias para programar el GPS y OSM:

import org.osmdroid.tileprovider.tilesource.TileSourceFactory;
import org.osmdroid.util.GeoPoint;
import org.osmdroid.views.MapController;
import org.osmdroid.views.MapView;
import org.osmdroid.views.overlay.SimpleLocationOverlay;
import android.location.Location;
import android.location.LocationManager;

Para obtener la localización del dispositivo mediante coordenadas se puede crear el siguiente método:

Location getMyLocation(){
	LocationManager locationManager = (LocationManager) this.getSystemService(Context.LOCATION_SERVICE);
		
		return locationManager.getLastKnownLocation(LocationManager.NETWORK_PROVIDER);
		}

En el método anterior, primero se crea una variable de tipo locationManager (la cual fue importada anteriormente) esta variable permite acceder al servicio de GPS, luego se solicita retornar la última localización conocida en formato de coordenadas.

Para instanciar el mapa se escriben las siguientes dos lineas de código:

MapView mapView = (MapView) findViewById(R.id.mapView);
mapView.setTileSource(TileSourceFactory.MAPQUESTOSM);

Y adicionalmente se desea poder tener funcionalidades como poder hacer zoom y ver una figura que represente la ubicación del dispositivo en el mapa.

Para el zoom:

MapController mapController = mapView.getController();
mapController.setZoom(<un numero entero>);

Para el icono q representa la ubicación actual en el mapa:

SimpleLocationOverlay myLocationOverlay = new SimpleLocationOverlay(this);
mapView.getOverlays().add(myLocationOverlay);
 
mapController.setCenter(myLocation);
myLocationOverlay.setLocation(myLocation);

Las primeras dos lineas definen la apariencia o dibujo que tendrá la etiqueta que la representa la localización, las otras establecen la posición en el mapa donde sí ubicará dicha etiqueta según las coordenadas obtenidas por el GPS.

Una vez que se compila la aplicación, el mapa se verá así:

Anexos

1. Para el desarrollo de la interfaz gráfica para crear una aplicación en Android se debe descargar el paquete “ADT Bunddle” el cual incluye el Eclipse + ADT (Android Developer Tools) plugin, Android SDK tools, Android Plataform-tools, la última plataforma de Android y the lastest Android system image for the emulator. Este paquete puede ser descargado desde:
Android SDK

Después de instalado el ADT, se procede a instalar todas las herramientas y que hacen falta siguiendo el procedimiento descrito en el sitio: Packages of Android

Referencias

1) Android. Adding Platforms and Packages. Recuperado de: http://developer.android.com/sdk/installing/adding-packages.html.

2) Android. Get the Android SDK. Recuperado de: http://developer.android.com/sdk/index.html#ExistingIDE

Table of Contents