PDM Avanzado GoogleMaps

De Manuais Informática - IES San Clemente.
Ir a la navegación Ir a la búsqueda

Introdución

Neste punto imos aprender como debuxar e controlar un Mapa de GoogleMaps.

Debido a que o control que debuxa o mapa fai uso dun MapFragment e esta clase foi introducida a partires da API 12 (Android 3.1) teremos dúas formas de utilizalo dependendo da API mínima ó que vaia dirixida a nosa aplicación.

Para poder utilizar un Google Map necesitaremos:

  • Google Play services (a aplicación debe estar instalada no dispositivo real. Isto xa se fai automaticamente a partires da versión 2.3).
  • Google Maps API key: Unha clave que nos proporciona Google e que ten estar posta no AndroidManifiest.xml. Para ser exactos imos necesitar dúas. Unha para a versión de desenrolo e outra para cando xeremos o APK.
  • Unha serie de permisos a engadir no AndroidManifiest.xml


Aclaración sobre o dispositivo virtual android (AVD)

Para poder utilizar o mapa nun AVD é necesario descargar unha imaxe que sexa Google API.

PDM Avanzada GoogleMap 17.jpg

Unha vez descargada e tendo un AVD con esta imaxe, teremos que cambiar as propiedades do proxecto para indicarlle que imos utilizar dita imaxe:

PDM Avanzada GoogleMap 18.jpg


No caso de utilizar a máquina de VirtualBox entregada para este curso, isto non será necesario.

Importación de Google Play Services ó noso proxecto

Debemos de engadir a librería de Google Play Services ó noso proxecto.

  • Nota: Se usades Android Studio neste enlace indica como tedes que facer.
  • Nota: Nun AVD funcionará nunha versión Android 4.2.2 ou superior cunha imaxe Google API.


Para facelo:


A maiores debemos engadir o seguinte permiso no arquivo AndroidManifiest.xml:

  • Dentro da entrada <application>:
 1     <application
 2         android:allowBackup="true"
 3         android:icon="@drawable/ic_launcher"
 4         android:label="@string/app_name"
 5         android:theme="@style/AppTheme" >
 6     
 7         <meta-data
 8             android:name="com.google.android.gms.version"
 9             android:value="@integer/google_play_services_version" />
10         ............



Para saber por código se un dispositivo ten o Google Play Service:

1 int resultCode =GooglePlayServicesUtil.isGooglePlayServicesAvailable(this);
2 
3 if (ConnectionResult.SUCCESS != resultCode) {
4 
5   // Neste caso ou non ten instalado o Google Play Services ou necesita actualizarse,...
6 }


En caso de erro podemos descubrir que pasa:

1 GooglePlayServicesUtil.getErrorDialog(resultCode, this, 0).show();

Xeración das API KEYS

Para poder utilizar un mapa de Google necesitamos xerar unha Key dende a consola de Google. Para ser máis concretos imos necesitar xerar dúas Keys, unha para facer procesos de debugger (cando estamos a desenrolar a aplicación en Eclipse) e outra xa definitiva para cando xeremos o APK que será entregado ou descargado polos usuarios da nosa aplicación.

Obtención da pegada dixital SHA1

Un paso necesario para obter esa Key é obter a pegada dixital.

Como comentamos antes imos ter dúas, unha mentres estamos a desenrolar a aplicación e outra para cando teñamos a aplicación rematada e lista para entregar ós usuarios.

Obtención da pegada dixital SHA1 Depuración

Graficamente
Dende consola

Esta información tamén se pode obter dende unha consola ou terminal. En Windows é mellor utilizar unha consola con permisos administrativos (executar como administrador).

Debemos situarnos coa orde cd (se non o temos no path) no cartafol onde estea instalado o JDK e dentro deste no cartafol /bin/.

Nese cartafol se atopa o executable keytool.

  • LINUX:
1 ./keytool -list -v -keystore ~/.android/debug.keystore -alias androiddebugkey -storepass android -keypass android


  • WINDOWS:
1 keytool -list -v -keystore "%USERPROFILE%\.android\debug.keystore" -alias androiddebugkey -storepass android -keypass android

Obtención da pegada dixital SHA1 Produción

Esta a obteremos cando a aplicación estea rematada e xeremos o apk a entregar ós usuarios.

Esta parte está contemplada na Unidade de empaquetado e distribución.


Obtención da API KEY

Unha vez temos a pegada dixital, temos que acceder ó sitio web: https://code.google.com/apis/console/?noredirect

Nota: Solicitará entrar cunha conta de gmail. Se non a temos teremos que rexistrarnos e crear unha nova.

O proceso é o seguinte:

Nota Importante:

Lembrar que se queremos entregar a aplicación aos usuarios (xerar o APK) debemos de obter e utilizar a API KEY a partires da SHA1 de produción, como indicamos neste enlace.
O lóxico é que primeiro xeredes unha API KEY a partires do voso Eclipse (cando se está a facer probas). Como xa está xerada a API KEY o único que teredes que facer é editar quen ten acceso a utilizar esa api key premendo o botón 'Editar Aplicaciones Android Permitidas'. Nese intre teredes que poñer o SHA1 obtido do voso almacén de claves (obtención da SHA1).

Permisos necesarios e uso da nova API KEY

Para poder utilizar GoogleMap debemos modificar o arquivo AndroidManifiest.xml coas seguintes entradas:

  • Xusto antes da etiqueta </application>:
1 ...........
2     <meta-data
3        android:name="com.google.android.maps.v2.API_KEY"
4        android:value="API_KEY"/>
5 </application>
6 ...........
Tendo que substituír en value API_KEY pola API KEY xerada no paso anterior.


  • Debemos engadir os seguintes permisos:
1     <uses-permission android:name="android.permission.INTERNET" />
2     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
3     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />


  • Os seguintes permisos non son obrigatorios pero se recomendan utilizalos:
1     <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
2     <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
O primeiro serve para permitir que se utilice o WIFI ou antenas móbiles para determinar a localización.
O segundo serve para permitir que se utilice o GPS para determinar a localización.


  • É necesario que a tarxeta gráfica soporte OPEN GL 2.0 para a renderización do mapa.
1 <uses-feature
2         android:glEsVersion="0x00020000"
3         android:required="true"/>

Renderizado do MAPA

Debemos crear un layout para a activity no que se visualizará o mapa.

Aquí temos varias opcións:

  • Podemos facer que o mapa ocupe todo o layout:
1 <?xml version="1.0" encoding="utf-8"?>
2 <fragment xmlns:android="http://schemas.android.com/apk/res/android"
3           android:id="@+id/map"
4           android:layout_width="match_parent"
5           android:layout_height="match_parent"
6           android:name="com.google.android.gms.maps.MapFragment"/>


  • Podemos facer que o mapa forme parte dun layout:
 1 <?xml version="1.0" encoding="utf-8"?>
 2 <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
 3     xmlns:tools="http://schemas.android.com/tools"
 4     android:layout_width="match_parent"
 5     android:layout_height="match_parent"
 6 >
 7 
 8 	<fragment 
 9           android:id="@+id/map"
10           android:layout_width="match_parent"
11           android:layout_height="match_parent"
12           android:name="com.google.android.gms.maps.MapFragment"/>
13 
14 </RelativeLayout>


  • Unha vez definido o layout creamos a activity que o carga:
 1 import android.app.Activity;
 2 import android.os.Bundle;
 3 
 4 public class UD6_02_Mapa extends Activity {
 5 
 6 	@Override
 7 	protected void onCreate(Bundle savedInstanceState) {
 8 		super.onCreate(savedInstanceState);
 9 		setContentView(R.layout.layout_anteriormente_definido);
10 	}
11 }


Se facemos todos os pasos indicados teremos como resultado algo parecido a isto:

PDM Avanzada GoogleMap 19.jpg


Versións da API

Como podemos comprobar o mapa utiliza unha clase MapFragment para visualizarse.

Esta clase foi introducida a partires da API 12 (Android 3.1). Se necesitamos desenrolar unha aplicación para unha versión anterior teremos que modificar o layout e poñer o seguinte:

1 <?xml version="1.0" encoding="utf-8"?>
2 <fragment xmlns:android="http://schemas.android.com/apk/res/android"
3           android:id="@+id/map"
4           android:layout_width="match_parent"
5           android:layout_height="match_parent"
6           android:name="com.google.android.gms.maps.SupportMapFragment"/>
7 />


  • Neste caso a activity debe ser unha subclase da clase FragmentActivity que se atopa na librería de compatibilidade v4:
 1 import android.os.Bundle;
 2 import android.support.v4.app.FragmentActivity;
 3 
 4 public class UD6_02_Mapa  extends FragmentActivity {
 5 
 6 	@Override
 7 	protected void onCreate(Bundle savedInstanceState) {
 8 		super.onCreate(savedInstanceState);
 9 		setContentView(R.layout.activity_ud6_02_mapa);
10 	}
11 }

Manexo do Mapa

Unha vez temos o mapa no layout podemos facer referencia a el dende a activity e modificar propiedades, facer zoom, mover a cámara...

Faremos uso da clase GoogleMap:

  • Para referenciar o mapa:
1 import com.google.android.gms.maps.GoogleMap;
2 
3 private GoogleMap googleMap;
4 
5 googleMap = ((MapFragment) getFragmentManager().findFragmentById(R.id.map)).getMap();


  • Se necesitamos que o GoogleMap funcione en versións anteriores á API 12 (Android 3.1) teremos que refencialo desta forma, facendo uso da librería de compatibilidade v4:
1 import com.google.android.gms.maps.GoogleMap;
2 
3 private GoogleMap googleMap;
4 
5 googleMap = ((SupportMapFragment) getSupportFragmentManager().findFragmentById(R.id.map)).getMap();


Entre os métodos que podemos empregar:

  • setMapType(TIPO_MAPA): Cambio o tipo de mapa, sendo TIPO_MAPA:
  • GoogleMap.MAP_TYPE_TERRAIN
  • GoogleMap.MAP_TYPE_NORMAL
  • GoogleMap.MAP_TYPE_SATELLITE
  • GoogleMap.MAP_TYPE_HYBRID


  • moveCamera(TIPO_MOVEMENTO): Move a cámara directamente.
  • animateCamera(TIPO_MOVEMENTO): Move a cámara cunha animación.
sendo TIPO_MOVEMENTO:
  • CameraUpdateFactory.zoomIn(): Aumenta en 1 o zoom.
  • CameraUpdateFactory.zoomOut(): Diminúe en 1 o zoom.
  • CameraUpdateFactory.zoomTo(nivel_de_zoom): Nivel de zoom entre 2 e 21.
  • CameraUpdateFactory.newLatLng(lat, long): Nova lonxitude e latitude.
  • CameraUpdateFactory.newLatLngZoom(lat, long, zoom): Nova lonxitude e latitude cun zoom determinado.
  • CameraUpdateFactory.scrollBy(scrollHorizontal, scrollVertical): Fai un movemento en scroll desprezando o mapa o número de pixeles indicados.
Nota: Para mover a cámara ou cambiar o zoom faremos uso da clase CameraUpdateFactory e os seus métodos de clase.


Exemplo de código:
1 LatLng pos = new LatLng(latitude, lonxitude);
2 googleMap.moveCamera(CameraUpdateFactory.newLatLngZoom(pos,15));

Importante: Fixarse como para manexar lonxitudes-latitudes temos que facer uso da clase LatLng.


  • getCameraPosition(): Devolve un obxecto da clase CameraPosition a posición da cámara. Dentro desta clase podemos chamar á propiedade target que nos devolve un obxecto da clase LatLng que representa a lonxitude e latitude da posición da cámara.
Exemplo de código:
1 CameraPosition posCam = googleMap.getCameraPosition();
2 LatLng posicion = posCam.target;


Tamén podemos obter o zoom, orientación e ángulo accedendo ás propiedades zoom, bearing e tilt.


Marcas no Mapa

Outra das aplicacións que pode ter o uso de GoogleMap é indicar mediante iconas, posicións concretas do mapa no que alberguemos certa información.

PDM Avanzada GoogleMap 22.jpg

Isto o conseguimos coas clases Marker e MarkerOptions.

  • MarkerOptions: Crea unha marca nova no mapa.

A forma de agregala sería:

1 googleMap.addMarker(new MarkerOptions()
2 		.position(googleMap.getCameraPosition().target)
3 		.title("TI")
4 		.snippet("Ti nesta posición:"+ googleMap.getCameraPosition().target.toString())
5 		.icon(BitmapDescriptorFactory.fromResource(R.drawable.ic_launcher)));
Onde:
  • position: Posición da marca.
  • title: Texto que aparece na marca.
  • icon: Icona asociada á marca.
  • sniper: Texto que aparece cando pulsamos sobre a marca no mapa.

A chamada ó método addMarker nos devolve o obxecto da clase Marker:


  • Marker: Representa a marca no mapa.
1 Marker marca;
2 marca = googleMap.addMarker(new MarkerOptions()
3 		.position(googleMap.getCameraPosition().target)
4 		.title("TI")
5 		.snippet("Ti nesta posición:"+ googleMap.getCameraPosition().target.toString())
6 		.icon(BitmapDescriptorFactory.fromResource(R.drawable.ic_launcher)));
A través deste obxecto podemos obter:
  • getPosition(): A posición (obxecto da clase LatLng).
  • getRotation(): A súa rotación.
  • getTitle(): O seu título.
.....
  • remove(): eliminamos a marca do mapa.
  • setVisible(boolean): Indicamos se queremos que sexa visible a marca no mapa.

Liñas no Mapa

Algunhas veces pode sernos de utilizade 'unir' diferentes marcas no mapa (para indicar unha ruta por exemplo).

PDM Avanzada GoogleMap 21.jpg

Para facelo debemos utilizar a clase PolygonOptions.

Esta clase dispón do método add no que se lle pasa a posición a engadir (en forma de obxecto da clase LatLng).

Cando se engade un obxecto desta clase ó mapa, este une os puntos.

Por exemplo:

1 PolygonOptions polOpt = new PolygonOptions();
2 polOpt.add(new LatLng(10,10));
3 polOpt.add(new LatLng(11,11));
4 polOpt.add(new LatLng(12,12));
5 polOpt.strokeColor(Color.BLUE);
6 				
7 googleMap.clear();
8 googleMap.addPolygon(polOpt);


  • Liña 5: Establece unha cor para a liña que vai unir os diferentes puntos.
  • Liña 7: Limpa o mapa de marcas e liñas previamente debuxadas.
  • Liña 8: Engade ó mapa o conxunto de liñas.




Caso Práctico

O obxectivo desta práctica é crear unha pantalla cun mapa de google.

Poderemos cambiar de tipo de mapa (Satélite / Terrestre), movernos ó centro do mapa e gardar a posición e ir uníndoas cun polígono.

O aspecto desta práctica é o seguinte:


PDM Avanzada GoogleMap 20.jpg
  • Como funciona a práctica:
A nosa icona sempre se visualizará no centro do mapa. Esta será a posición que poderemos gardar como 'puntos de paso' e que despois se unirán formando unha ruta.
Na parte superior temos:
Botón Satélite: Cambia o aspecto a modo satélite.
Botón Terrestre: Cambia o aspecto a modo terrestre.
Botón Marcar: Garda nun array a posición da icona. Unha vez temos gardados máis de dous, crea un polígono unindo os puntos.
Botón Mover: Move a icona ó centro do mapa. Para mover o mapa temos que premer sobre o mapa e sen soltar, arrastrar.
Ó premer sobre a icona informa da posición e amosa un texto.


IMPORTANTE: Aspectos a ter en conta para que funcione este práctica

  • Necesitaremos xerar unha API KEY para o voso eclipse e proxecto como vimos neste punto: Obtención da API KEY.
  • Unha vez obtida debemos de escribila no sitio correspondente do arquivo AndroidManifiest.xml


Creamos a activity

  • Nome do proxecto: UD6_02_Mapa
  • Nome da activity: UD6_02_Mapa.java


Código do layout xml

 1 <?xml version="1.0" encoding="utf-8"?>
 2 <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
 3     xmlns:tools="http://schemas.android.com/tools"
 4     android:layout_width="match_parent"
 5     android:layout_height="match_parent"
 6    
 7 >
 8 
 9 	<fragment 
10           android:id="@+id/map"
11           android:layout_width="match_parent"
12           android:layout_height="match_parent"
13           android:name="com.google.android.gms.maps.MapFragment"/>
14 
15 	<Button
16 	    android:id="@+id/UD6_02_btnSatelite"
17 	    android:layout_width="wrap_content"
18 	    android:layout_height="wrap_content"
19 	    android:layout_alignParentLeft="true"
20 	    android:layout_alignParentTop="true"
21 	    android:text="Satelite" />
22 
23 	<Button
24 	    android:id="@+id/UD6_02_btnTerrestre"
25 	    android:layout_width="wrap_content"
26 	    android:layout_height="wrap_content"
27 	    android:layout_alignParentTop="true"
28 	    android:layout_toRightOf="@+id/UD6_02_btnSatelite"
29 	    android:text="Terrestre" />
30 
31 	<Button
32 	    android:id="@+id/UD6_02_btnMarcar"
33 	    android:layout_width="wrap_content"
34 	    android:layout_height="wrap_content"
35 	    android:layout_alignParentTop="true"
36 	    android:layout_toRightOf="@+id/UD6_02_btnTerrestre"
37 	    android:text="Marcar" />
38 
39 	<Button
40 	    android:id="@+id/UD6_02_btnMover"
41 	    android:layout_width="wrap_content"
42 	    android:layout_height="wrap_content"
43 	    android:layout_alignParentTop="true"
44 	    android:layout_toRightOf="@+id/UD6_02_btnMarcar"
45 	    android:text="Mover" />
46 
47 </RelativeLayout>


Código da clase UD6_02_Mapa
Obxectivo: Traballar cun mapa de Google Map utilizando marcas.

  1 import java.util.ArrayList;
  2 
  3 import android.app.Activity;
  4 import android.graphics.Color;
  5 import android.os.Bundle;
  6 import android.view.View;
  7 import android.view.View.OnClickListener;
  8 import android.widget.Button;
  9 import android.widget.Toast;
 10 
 11 import com.google.android.gms.maps.CameraUpdateFactory;
 12 import com.google.android.gms.maps.GoogleMap;
 13 import com.google.android.gms.maps.MapFragment;
 14 import com.google.android.gms.maps.model.BitmapDescriptorFactory;
 15 import com.google.android.gms.maps.model.LatLng;
 16 import com.google.android.gms.maps.model.Marker;
 17 import com.google.android.gms.maps.model.MarkerOptions;
 18 import com.google.android.gms.maps.model.PolygonOptions;
 19 
 20 public class UD6_02_Mapa extends Activity {
 21 
 22 	private GoogleMap googleMap;
 23 	private Marker marcaActual;
 24 	private ArrayList<LatLng>marcas;
 25 	
 26 	private void xestionarEventos(){
 27 		
 28 		Button btnSatelite = (Button)findViewById(R.id.UD6_02_btnSatelite);
 29 		btnSatelite.setOnClickListener(new OnClickListener() {
 30 			
 31 			@Override
 32 			public void onClick(View arg0) {
 33 				// TODO Auto-generated method stub
 34 			
 35 				googleMap.setMapType(GoogleMap.MAP_TYPE_SATELLITE);
 36 				
 37 			}
 38 		});
 39 		Button btnTerrestre = (Button)findViewById(R.id.UD6_02_btnTerrestre);
 40 		btnTerrestre.setOnClickListener(new OnClickListener() {
 41 			
 42 			@Override
 43 			public void onClick(View arg0) {
 44 				// TODO Auto-generated method stub
 45 			
 46 				googleMap.setMapType(GoogleMap.MAP_TYPE_TERRAIN);
 47 				
 48 			}
 49 		});
 50 		
 51 		Button btnMover = (Button) findViewById(R.id.UD6_02_btnMover);
 52 		btnMover.setOnClickListener(new OnClickListener() {
 53 
 54 			@Override
 55 			public void onClick(View arg0) {
 56 				// TODO Auto-generated method stub
 57 
 58 				if (marcaActual != null)
 59 					marcaActual.remove();
 60 
 61 				marcaActual = googleMap.addMarker(new MarkerOptions()
 62 						.position(googleMap.getCameraPosition().target)
 63 						.title("TI")
 64 						.snippet(
 65 								"Ti nesta posición:"
 66 										+ googleMap.getCameraPosition().target
 67 												.toString())
 68 						.icon(BitmapDescriptorFactory
 69 								.fromResource(R.drawable.ic_launcher)));
 70 
 71 			}
 72 		});
 73 		
 74 		Button btnMarcar = (Button)findViewById(R.id.UD6_02_btnMarcar);
 75 		btnMarcar.setOnClickListener(new OnClickListener() {
 76 			
 77 			@Override
 78 			public void onClick(View arg0) {
 79 				// TODO Auto-generated method stub
 80 	
 81 				marcas.add(googleMap.getCameraPosition().target);
 82 				
 83 				PolygonOptions polOpt = new PolygonOptions();
 84 				for (LatLng lugar : marcas){
 85 					polOpt.add(lugar);
 86 				}
 87 				polOpt.strokeColor(Color.BLUE);
 88 				
 89 				googleMap.clear();
 90 				googleMap.addPolygon(polOpt);
 91 
 92 				marcaActual = googleMap.addMarker(new MarkerOptions()
 93 				.position(googleMap.getCameraPosition().target)
 94 				.title("TI")
 95 				.snippet(
 96 						"Ti nesta posición:"
 97 								+ googleMap.getCameraPosition().target
 98 										.toString())
 99 				.icon(BitmapDescriptorFactory
100 						.fromResource(R.drawable.ic_launcher)));
101 
102 			}
103 		});
104 
105 	}
106 	
107 	private void prepararMapa(){
108 		
109 		googleMap = ((MapFragment) getFragmentManager().findFragmentById(R.id.map)).getMap();
110 		
111 		if (googleMap==null){
112 			Toast.makeText(this, "ERRO O OBTER O MAPA", Toast.LENGTH_LONG).show();
113 			finish();
114 		}
115 		
116 		LatLng pos = new LatLng(42.879985, -8.544855);	// Posición de Santiago de Compostela
117 		 
118 		marcaActual = googleMap.addMarker(new MarkerOptions()
119 			.position(pos)
120 			.title("TI")
121 			.snippet("Ti nesta posición:" + pos.toString())
122 			.icon(BitmapDescriptorFactory.fromResource(R.drawable.ic_launcher))
123 				);
124 		
125 		googleMap.moveCamera(CameraUpdateFactory.newLatLngZoom(marcaActual.getPosition(),16));
126 	}
127 	
128 	@Override
129 	protected void onCreate(Bundle savedInstanceState) {
130 		super.onCreate(savedInstanceState);
131 		setContentView(R.layout.activity_ud6_02__mapa);
132 
133 		marcas = new ArrayList<LatLng>();
134 		prepararMapa();
135 		xestionarEventos();
136 	}
137 }
  • Liña 22: Definimos o mapa de google.
  • Liña 23: A marca que representa a nosa posición. É necesaria xa que se queremos movela temos que primeiro eliminala e despois volvela a crear.
  • Liña 24: Definimos o array que vai representar o conxunta de puntos que temos gardados.
  • Liña 35: Cambiamos o modo a Satélite ó premer o botón.
  • Liña 46: Cambiamos o modo a Terrestre ó premer o botón.
  • Liñas 58-69: Xestionamos o evento Click sobre o botón mover.
  • Liñas 58-59: Eliminamos a icona do mapa.
  • Liñas 61-69: Agregamos unha nova icona (marca) na posición actual da cámara.
  • Liñas 81-100: Xestionamos o evento Click sobre o botón marcar.
  • Liña 81: Agregamos a posición actual da cámara ó array de marcas.
  • Liñas 83-86: Creamos un PolygonOptions e agregamos todas as marcas gardadas no array.
  • Liña 87: Establecemos de cor azul a liña que une os puntos.
  • Liña 89: Limpa o mapa.
  • Liña 90: Agrega o PolygonOptions para debuxar as liñas entre os puntos.
  • Liñas 92-100: Agregamos unha nova icona (marca) na posición actual da cámara.
  • Liñas 107-126: Obtén unha referencia ó mapa e crea unha marca (icona) en Santiago de Compostela.
  • Liña 109: Obtén unha referencia ó mapa.
  • Liñas 116-123: Crea unha marca (icona) en Santiago de Compostela.
  • Liña 125: Move a cámara do mapa á posición da marca cun zoom de 15.



-- Ángel D. Fernández González e Carlos Carrión Álvarez -- (2014).