MyLocation

Introducción
Este proyecto tiene por objetivo ilustrar lo siguiente:
• Solicitar permisos para acceder a información de localización.
• Activar un listener para obtener la localización.
• Obtener la última localización conocida.

Creando el proyecto
En Android Studio, creamos un proyecto nuevo, con el nombre MyLocation. Adicionamos al
proyecto un Activity de tipo Basic Activity.

Completando características en la UI
Abrimos para edición el archivo content_main.xml y modificamos las propiedades del widget de tipo
TextView que se adiciona por defecto, de tal forma que se aprecie de la siguiente manera.

<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Hello World!"
android:id="@+id/locationTextView"/>

Agregando atributos y constantes en el Activity

Abrimos para edición el archivo MainActivity.java.

Declaramos los siguientes atributos y constantes dentro de la clase, antes de iniciar la declaración de
métodos. Estos atributos nos serán de utilidad para implementar los diversos aspectos de la
experiencia.

static final String TAG = "MyLocation";

String locationProvider = LocationManager.GPS_PROVIDER;
LocationManager locationManager;
LocationListener locationListener;
final static int PERMISSIONS_REQUEST_ACCESS_LOCATION = 100;
boolean locationPermissionGranted = false;
TextView locationTextView;

Luego de ello, colocamos la siguiente línea de código en el método onCreate(), lo cual nos permitirá
contar con una variable que nos ayude a presentar en el TextView la información de la ubicación
actual.

locationTextView = (TextView) findViewById(R.id.locationTextView);

Verificando permisos

Como sabemos, la información de localización es considerada privada en Android, por lo que

requiere de permisos para su uso. Nuestra experiencia incluye acceder y presentar la localización
actual, por lo que necesitamos validar y solicitar de ser requeridos los permisos necesarios.

En el archivo MainActivity.java, adicionamos los siguientes bloques de código para implementar dos
métodos.

El primero, validatePermissions(), realiza una verificación para ver si contamos con el permiso para
acceder a la localización. De no contar con dicho permiso, procedemos a solicitarlo vía el método
requestPermissions().
private void validatePermissions() {
if (ContextCompat.checkSelfPermission(this,
Manifest.permission.ACCESS_FINE_LOCATION) !=
PackageManager.PERMISSION_GRANTED) {
if (ActivityCompat.shouldShowRequestPermissionRationale(this,
Manifest.permission.ACCESS_FINE_LOCATION)) {
} else {
ActivityCompat.requestPermissions(this,
new String[]{Manifest.permission.ACCESS_FINE_LOCATION,
Manifest.permission.ACCESS_COARSE_LOCATION},
PERMISSIONS_REQUEST_ACCESS_LOCATION);
}
} else {
locationPermissionGranted = true;
}
}

Como podemos observar, aquí utilizamos la constante

PERMISSIONS_REQUEST_ACCESS_LOCATION que declaramos previamente. Si contamos con el
permiso, establecemos una variable locationPermissionGranted en true.

El segundo método que vamos a implementar es un requisito para el sistema de permisos de Android
en tiempo de ejecución. onRequestPermissionsResult() nos permitirá comprobar qué resultó de la
solicitud de permisos al usuario. Aquí tenemos la oportunidad de consultar para cada permiso
solicitado, si el usuario concedió dicho permiso o no. En función a ello en nuestro caso, actualizamos
el valor de la variable locationPermissionGranted.

@Override
public void onRequestPermissionsResult(int requestCode,
String permissions[], int[] grantResults) {
switch (requestCode) {
case PERMISSIONS_REQUEST_ACCESS_LOCATION: {
if (grantResults.length > 0 && grantResults[0] ==
PackageManager.PERMISSION_GRANTED) {

// permission was granted, yay! Do the

// contacts-related task you need to do.
locationPermissionGranted = true;

} else {

// permission denied, boo! Disable the

// functionality that depends on this permission.
locationPermissionGranted = false;
}
return;
}

// other 'case' lines to check for other

// permissions this app might request
}
}

Adicionando el comportamiento para actualizar la UI

Nos corresponde ahora implementar el método refreshCurrentLocation(). Para ello crearemos un

método privado con un parámetro de tipo Location. Con el valor de dicho parámetro realizaremos dos
acciones, primero generaremos una entrada de Log con la localización actual, para luego establecer
el valor de la propiedad text con la información de localización de tal forma que la aprecie el usuario.

private void refreshCurrentLocation(Location location) {

String locationDescription = "Latitude: " +
String.valueOf(location.getLatitude()) + " Longitude: " +
String.valueOf(location.getLongitude());
Log.d(TAG, locationDescription);
 locationTextView.setText("My Current Location is " + locationDescription);
}

Implementando comportamiento para acceder a localización en el Activity

Ahora que ya contamos con el manejo de permisos en tiempo de ejecución, procedemos a

implementar la lógica para acceder a la información de localización. Para ello, instanciamos un objeto
de la clase LocationManager. Del mismo modo instanciamos un objeto de la clase
LocationListener pasando un bloque de código en el constructor, implementando los métodos
requeridos.

private void setupLocationUpdates() {

validatePermissions();
if (locationPermissionGranted) {
locationManager = (LocationManager)
this.getSystemService(Context.LOCATION_SERVICE);
// Define a listener that responds to location updates
locationListener = new LocationListener() {
public void onLocationChanged(Location location) {
// Called when a new location is found by the network location provider.
refreshCurrentLocation(location);

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

}

public void onProviderEnabled(String provider) {

}

public void onProviderDisabled(String provider) {

}
};
if (ActivityCompat.checkSelfPermission(this,
Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED &&
ActivityCompat.checkSelfPermission(this,
Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
return;
}
locationManager.requestLocationUpdates(locationProvider, 0, 0,
locationListener);
refreshCurrentLocation(locationManager.getLastKnownLocation(locationProvider));

}
}

El método que hemos implementado previamente, refreshCurrentLocation, es invocado en dos

momentos. Primero lo invocamos cuando acabamos de configurar el Listener y segundo, dentro del
cuerpo del Listener, específicamente en el método onLocationChanged(). De esta forma, al iniciar la
aplicación, el usuario aprecia un valor inicial con la última localización conocida (gracias a una
llamada al método getLastKnowLocation() del objeto locationManager).

Si ejecuta la aplicación observaremos dos cosas, primero la solicitud de permiso para acceder a
Localización y luego la vista por defecto mostrando el texto que contiene la Latitud y Longitud
actuales.