Android

Notificaciones

Básica

El código para programar notifiaciones ha cambiado a partir de Android 8.

@TargetApi(Build.VERSION_CODES.JELLY_BEAN)
public void lanzarNotificacion(View v){
	NotificationUtils mNotificationUtils;
	if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
		// only for Oreo(8) and newer versions
		mNotificationUtils = new NotificationUtils(this, true);
	}else{
		mNotificationUtils = new NotificationUtils(this, false);
	}
	Notification.Builder nb = mNotificationUtils.getChannelNotification("Titulo", "Mensaje", R.raw.hakunamatata);
	mNotificationUtils.getManager().notify(101, nb.build());
}

public class NotificationUtils extends ContextWrapper {

    private NotificationManager mManager;
    private boolean isAndroid8;
    public static final String ANDROID_CHANNEL_ID = "com.pablomonteserin.ANDROID";
    public static final String ANDROID_CHANNEL_NAME = "ANDROID CHANNEL";

    public NotificationUtils(Context base, boolean isAndroid8) {
        super(base);
        this.isAndroid8 = isAndroid8;
        if(isAndroid8){
           createChannels();
        }
    }

    @TargetApi(26)
    public void createChannels() {
        // create android channel
        NotificationChannel androidChannel = new NotificationChannel(ANDROID_CHANNEL_ID,
                ANDROID_CHANNEL_NAME, NotificationManager.IMPORTANCE_DEFAULT);
        // Sets whether notifications posted to this channel should display notification lights
        androidChannel.enableLights(true);
        // Sets whether notification posted to this channel should vibrate.
        androidChannel.enableVibration(true);
        // Sets the notification light color for notifications posted to this channel
        androidChannel.setLightColor(Color.GREEN);
        // Sets whether notifications posted to this channel appear on the lockscreen or not
		// androidChannel.setLockscreenVisibility(Notification.VISIBILITY_PRIVATE);
        androidChannel.setLockscreenVisibility(Notification.VISIBILITY_PUBLIC);

        getManager().createNotificationChannel(androidChannel);
    }

    public NotificationManager getManager() {
        if (mManager == null) {
            mManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
        }
        return mManager;
    }

    public Notification.Builder getChannelNotification(String title, String body,int sound) {
        Notification.Builder builder;

        if(isAndroid8){
            builder  = new Notification.Builder(getApplicationContext(), ANDROID_CHANNEL_ID);
        }else{
            builder = new Notification.Builder(getApplicationContext());
        }
        builder .setContentTitle(title)
                .setContentText(body)
                .setSmallIcon(android.R.drawable.stat_notify_more)
                .setAutoCancel(true);
        return builder;
    }
}

Ejerccio

Hacer que la notificación muestre una imagen

...
Bitmap aperturaabductoresBitmap = BitmapFactory.decodeResource(getResources(),
                            R.drawable.aperturaabductores);
...
nb.setStyle(new Notification.BigPictureStyle().bigPicture(bitmap));

Intent notificationIntent = new Intent(this, NotificacionesActivityAbierto.class);

PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, notificationIntent, 0);
...
.setContentIntent(pendingIntent);

Temporizadores

Son aquellas clases que nos permiten programar tareas que se ejecutarán al cabo de un tiempo.

Recogemos 3 grandes tipos:

• CounterTimeDown: nos permite ejecutar un evento cada cierto tiempo (siempre que la aplicación esté abierta, si la app está en segundo plano, dará problemas).

  CountDownTimer timer = new CountDownTimer(3000, 1000) {
  	private int counter;
  
  	public void onTick(long millisUnistilFinished) {
  		Log.d("traza", "Se ejecuta el timer");
  	}
  }.start();

  Para cancelarlo:if(isMyServiceRunning(		Servicio.class)){
  	CountDownTimerServiceMovil.timer.cancel();
  }
  
  private boolean isMyServiceRunning(Class<?> serviceClass) {
  	ActivityManager manager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
  	for (ActivityManager.RunningServiceInfo service : manager.getRunningServices(Integer.MAX_VALUE)) {
  		if (serviceClass.getName().equals(service.service.getClassName())) {
  			return true;
  		}
  	}
      return false;
  }

• AlarmManager: para ejecutar un evento en un momento concreto. Si la invocamos desde un servicio, podremos usarla aunque la applicación no esté abierta.

  Ejemplo de uso de AlarmManagerIntent myIntent = new Intent(this, AlarmReceiver.class);
  PendingIntent pendingIntent = PendingIntent.getBroadcast(this,id, myIntent, 0);
  
  AlarmManager alarmManager = (AlarmManager)getSystemService(Context.ALARM_SERVICE);
  alarmManager.set(AlarmManager.RTC_WAKEUP, System.currentTimeMillis() + delay, pendingIntent);
  //alarmManager.setRepeating(AlarmManager.RTC_WAKEUP, System.currentTimeMillis(), delay,pendingIntent);

  AlarmReceiver.javapublic class AlarmReceiver extends BroadcastReceiver {
      @Override
      public void onReceive(Context context, Intent intent) {
          Log.d("alarma: ", "MEHH");
          Toast.makeText(context, "ALARM!! ALARM!!", Toast.LENGTH_SHORT).show();
      }
  }

• JobScheduler: para ejecutar un evento aproximadamente en cierto momento. Supuestamente es evento se producirá más o menos pronto. Si queremos atenernos a un calendario, el AlarmManager será más apropiado. Consume menos recursos que el Alarm Manager, pero a cambio debemos especificar un rango de tiempo en el que se ejecutará cada evento. Si la invocamos desde un servicio, podremos usarla aunque la applicación no esté abierta.

  public class Util {
      public static void scheduleJob(Context context,int time) {
          ComponentName serviceComponent = new ComponentName(context, MovilJobService.class);
          JobInfo.Builder builder = new JobInfo.Builder(0, serviceComponent);
          builder.setMinimumLatency(time * 1000); // wait at least
          builder.setOverrideDeadline(time*1000+5000); // maximum delay
          //builder.setRequiredNetworkType(JobInfo.NETWORK_TYPE_UNMETERED); // require unmetered network
          //builder.setRequiresDeviceIdle(true); // device should be idle
          //builder.setRequiresCharging(false); // we don't care if the device is charging or not
          JobScheduler jobScheduler = context.getSystemService(JobScheduler.class);
          jobScheduler.schedule(builder.build());
      }
  }

  public class MovilJobService extends JobService {
      private static final String TAG = "SyncService";
  
      @Override
      public boolean onStartJob(JobParameters params) {
  }

Ejercicio yoga con notificaciones

Hacer una aplicación que cada 10 segundos nos vaya indicando un cambio de postura de yoga. Estos avisos serán hechos utilizando notificaciones en las que se oirá el sonido de la postura de yoga y se verá su fotografía. Además, al ir al activity de la aplicación, veremos la misma imagen que se mostraba en la notificación. Las notificaciones se ejecutarán aunque el móvil esté con la pantalla apagada o no estemos el el Activity de la aplicación.

Para ejecutar las notificaciones utilizaremos un servicio:

CountDownTimerServicepublic class CountDownTimerService extends Service {
	NotificationManager mNotificationManager;
	public static CountDownTimer timer;

	@Nullable
	@Override
	public IBinder onBind(Intent intent) {
		return null;
	}

	@Override
	public void onCreate() {
	super.onCreate();
		mNotificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
		final Service service = this;
		timer = new CountDownTimer(30000, 10000) {
			private int counter;
			public void onTick(long millisUntilFinished) {
			...

Cuando pulsemos un botón con el texto "terminar servicio" en el MainActivity, dejarán de mostrarse notifiaciones. Además, para poder modificar la imagen del Activity principal, haremos declararemos la variable vinculada a su ImageView pública y estática:

MainActivity.javapublic class MainActivity extends AppCompatActivity {
	public static ImageView iv;
	public static Activity contexto;
	...
	public void cerrarServicio(View v){
		CountDownTimerService.timer.cancel();
		stopService(new Intent(this, CountDownTimerService.class));
	}

Habrá que registrar el servicio en el AndroidManifest.xml

<service android:name="com.pablomonteserin.notifications.ejercicio_yoga.CountDownTimerService"/>

Descargar recursos

Broadcaster Receiver

Nos permiten enviar información a un Activity desde un servicio.

Servicio.javaIntent bc_intent = new Intent();
bc_intent.setAction("actualizar_foto");
bc_intent.putExtra("idDeLaFoto",R.drawable.torsion);
sendBroadcast(bc_intent);

Activity.java//Es necesario registrar un escuchador del broadcasterpublic void onResume(){
	super.onResume();
	IntentFilter intentFilter = new IntentFilter();
	intentFilter.addAction("actualizar_foto");
	registerReceiver(mMessageReceiver, intentFilter);
}
//Cuando el usuario cierre el Activity, dejaremos de escuchar el BroadcastReceiver
public  void onPause(){
	super.onPause();
	unregisterReceiver(mMessageReceiver);
}
private BroadcastReceiver mMessageReceiver = new BroadcastReceiver() {
	@Override
	public void onReceive(Context context, Intent intent) {
		ImageView iv = findViewById(R.id.imagen);
		iv.setImageResource(intent.getExtras().getInt("idDeLaFoto"));
	}
};

Solicitar el servicio de wifi y comprobar su estado

public class Main extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
        ConnectivityManager cm = (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
        TextView tv =  findViewById(R.id.textView1);
        boolean wifi = cm.getNetworkInfo(ConnectivityManager.TYPE_WIFI).isConnectedOrConnecting();
        if(wifi)tv.setText("El wifi está activo");
        else tv.setText("El wifi no está activo");
    }
}

Habrá que añadir un permiso al AndroidManifest.xml:
Doble click en AndroidManifest.xml → Pestaña Permissions → Add → Uses permission → android.permission.ACCESS_NETWORK_STATE

Otros controles

Desde el emulador → Applications → API Demos

Network connection

public class MainActivity extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
        final EditText et = (EditText) findViewById(R.id.editText1);
        final Button b = (Button) findViewById(R.id.button1);
        final TextView tv =  findViewById(R.id.textView1);
        
        b.setOnClickListener(new OnClickListener(){

			@Override
			public void onClick(View arg0) {
				try{
					URL url = null;
					url = new URL(et.getText().toString());
					URLConnection conn = url.openConnection();
					BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
					String line = "";
					while((line = reader.readLine()) != null){
						tv.append(line);
					}
				}catch(Exception e){
					
				}
			}
        	
        });
    }
}

AsynTask

Petición GET con AsynTask

new MiAsyncTask().execute("https://pablomonteserin.com/curso/php/res/leer-valor.php");

//El primer parámetro es lo que recibe doInBackground
//El segundo parámetro es lo que recibe un método que no estamos utilizando
//El tercer parámetro es lo que devuelve doInBackground (una cookie es un String)

private class MiAsyncTask extends AsyncTask<String, Integer, String> {
	//doInBackground es un método que se ejecuta en el background. 
	//Aquí realizamos operaciones pesadas que pueden durar mucho tiempo dando lugar a una excepción
	//doInBackground no debe tocar nada de la interfaz visual. Estas operaciones serán hechas en onPostExecute
	protected String doInBackground(String... urls) {
		URL url = new URL(urls[0]);
		URLConnection urlConnection = url.openConnection();
		BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(urlConnection.getInputStream()));
		String line;
		while ((line = bufferedReader.readLine()) != null){
			content.append(line + "\n");
		}
		bufferedReader.close();
		return content.toString();
	}

	//El método onPostExecute debe recibir lo que devuelve el doInBackground (en este caso, un String)
	protected void onPostExecute(String txt) {
	}
}

Ejercicio petición GET con AsynTask

El código UPC que escribimos se lo mandaremos a la url
https://pablomonteserin.com/curso/web/servidor/php/fundamentos/res/miUPCsearch.php?upc_code=upcCode

Para probar podremos utilizar el código:
upcCode=1234

Usaremos el permiso:

<uses-permission android:name="android.permission.INTERNET" />

Petición POST con AsyncTask

public class AsynTaskPorPOST extends AppCompatActivity {

@Override
protected void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);
	setContentView(R.layout.asyntask_post);
}

public void hacerPeticion(View v){
	new MiAsyncTask().execute("https://pablomonteserin.com/curso/php/res/peticion-post-android.php","option=3");
}

private class MiAsyncTask extends AsyncTask<String, Integer, String> {

	protected String doInBackground(String... params) {
		StringBuilder content = new StringBuilder();

		try
		{
			URL url = new URL(params[0]);

			HttpURLConnection connection = (HttpURLConnection) url.openConnection();

			connection.setRequestMethod("POST");
			connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
			connection.setRequestProperty("Accept", "*/*");

			connection.setDoOutput(true);
			BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(connection.getOutputStream()));
			writer.write(params[1]);
			writer.close();
			connection.connect();

			BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
			String line;
			while ((line = bufferedReader.readLine()) != null)
			{
				content.append(line + "\n");
			}
			bufferedReader.close();
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
		return content.toString();
	}
	protected void onPostExecute(String txt) {
//El método onPostExecute debe recibir lo que devuelve el doInBackground (en este caso, un String)
		Toast.makeText(AsynTaskPorPOST.this, txt,Toast.LENGTH_SHORT).show();
	}
}
}

Petición GET con Retrofit

Debemos importar las librerías de Retrofit

build.gradle (module)// Retrofit
api 'com.squareup.retrofit2:retrofit:2.3.0'
api 'com.squareup.retrofit2:converter-gson:2.3.0'

public class GetRequest extends AppCompatActivity{
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_get_request);
	}

	public void hacerPeticion(View v){
		Retrofit builder = new Retrofit.Builder()
			.baseUrl("https://swapi.co/api/")
			.addConverterFactory(GsonConverterFactory.create())
			.build();

		PabloAPI api = builder.create(PabloAPI.class);
		api.peticionGET().enqueue(new Callback<ResponseBody>() {
		
		@Override
		public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
			try {
				String respuesta = response.body().string();
				Log.d("RESPUESTA", respuesta);
				Toast.makeText(getBaseContext(), respuesta, Toast.LENGTH_LONG).show();

				JSONObject jObject = null;
				try {
					jObject = new JSONObject(respuesta);
					JSONArray jArray = jObject.getJSONArray("results");
					List <String> lista = fromArrayToList(jArray);
					ListView lv = findViewById(R.id.personas);
					lv.setAdapter(new ArrayAdapter(getBaseContext(),android.R.layout.simple_list_item_1,lista));
				} catch (JSONException e) {
					e.printStackTrace();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

		@Override
		public void onFailure(Call<ResponseBody> call, Throwable t) {
			Toast.makeText(GetRequestSimplificada.this, "Error", Toast.LENGTH_SHORT).show();
		}

		private List<String>fromArrayToList(JSONArray jArray){
			List<String>lista = new ArrayList<String>();
			for (int i=0; i < jArray.length(); i++){
				try {
					JSONObject oneObject = jArray.getJSONObject(i);
					// Pulling items from the array
					String name = oneObject.getString("name");
					lista.add(name);
				} catch (JSONException e) {
					// Oops
				}
			}
			return  lista;
		}
	});
}
}

public interface PabloAPI {
	@GET("people/")
	Call<ResponseBody> peticionGET();
}

Petición POST con Retrofit

El código es muy parecido al de la petición GET, pero cambiando el fichero API:

PabloMonteserinAPI.javapublic interface PabloMonteserinAPI {
	//Las cabeceras deben estar en consonancia con el tipo de dato que vamos a recuperar u obtendremos un error 406
	//  @Headers({"Accept: application/json"})
	@Headers({"Accept: text/html"})
	@FormUrlEncoded
	@POST("curso/php/res/peticion-post-android-2.php/")
	Call<ResponseBody> peticionPOST(@Field("nombre") String nombre, @Field("apellidos") String apellidos);
}

@Headers({"Accept: text/html"})
@POST("users/login")
Call<ResponseBody> login(@Body User user);

//api.peticionPOST("Pablo", "Monteserrín").enqueue(new Callback<ResponseBody>() {
	...

Subida de una imagen de la galería al servidor con Retrofit

Nesitaremos los siguientes permisos en el manifest:

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

SubidaImagen.javapublic class SubirImagen extends AppCompatActivity {

	private boolean isAndroid6;
	private final int MY_PERMISSIONS_REQUEST_CAMARA = 1;

	TextView image_name_tv;
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_subir_imagen);
		image_name_tv = findViewById(R.id.nombreFoto);

		if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
			isAndroid6 = true;
			askPermissionsIfneeded();
		}
	}
	private void askPermissionsIfneeded(){
		if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
			ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.READ_EXTERNAL_STORAGE}, MY_PERMISSIONS_REQUEST_CAMARA);
		}
	}

	@Override
	public void onRequestPermissionsResult(int requestCode,
                                           String permissions[], int[] grantResults) {
		switch (requestCode) {
			case MY_PERMISSIONS_REQUEST_CAMARA: {
			// If request is cancelled, the result arrays are empty.	
				if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
					// permission was granted, yay! Do the
					// contacts-related task you need to do.
				}else {
					// permission denied, boo! Disable the
					// functionality that depends on this permission.
				}
				return;
			}
            // other 'case' lines to check for other
            	// permissions this app might request
		}
	}

    public void sacarFoto(View v){
        Intent photoPickerIntent = new Intent(Intent.ACTION_PICK);
        photoPickerIntent.setType("image/*");
        startActivityForResult(photoPickerIntent, 1);

        /*Intent takePictureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
        	if (takePictureIntent.resolveActivity(getPackageManager()) != null) {
        	    startActivityForResult(takePictureIntent, 1);
        	}*/
    }

    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if (requestCode == 1)
            if (resultCode == Activity.RESULT_OK) {
                Uri selectedImage = data.getData();

                String filePath = getPath(selectedImage);
                String file_extn = filePath.substring(filePath.lastIndexOf(".") + 1);
                image_name_tv.setText(filePath);

                if (file_extn.equals("img") || file_extn.equals("jpg") || file_extn.equals("jpeg") || file_extn.equals("gif") || file_extn.equals("png")) {
                    File file = new File(filePath);
                    RequestBody requestFile =
                            RequestBody.create(
                                    MediaType.parse(getContentResolver().getType(selectedImage)),
                                    file
                            );
                    MultipartBody.Part body =
                            MultipartBody.Part.createFormData("sampleFile", file.getName(), requestFile);
                    String descriptionString = "hello, this is description speaking";
                    RequestBody description =
                            RequestBody.create(
                                    okhttp3.MultipartBody.FORM, descriptionString);
                    RetrofitService retrofitService = RetrofitService.getInstance();
                    PabloAPI api = retrofitService.getApiProxyServer();
                    api.uploadFile(description,body).enqueue(new Callback<ResponseBody>() {
                        @Override
                        public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                            Toast.makeText(SubirImagen.this, "Imagen subida", Toast.LENGTH_SHORT).show();
                        }

                        @Override
                        public void onFailure(Call<ResponseBody> call, Throwable t) {
                            Toast.makeText(SubirImagen.this, "Error", Toast.LENGTH_SHORT).show();
                        }
                    });

                } else {
                    //NOT IN REQUIRED FORMAT
                }
            }
    }

    public String getPath(Uri uri) {
        String[] filePathColumn = { MediaStore.Images.Media.DATA };
        Cursor cursor = getContentResolver().query(uri,filePathColumn, null, null, null);
        cursor.moveToFirst();
        int columnIndex = cursor.getColumnIndex(filePathColumn[0]);
        String picturePath = cursor.getString(columnIndex);
        cursor.close();
        return picturePath;
    }
}

PabloAPIpublic interface PabloAPI {
    @Multipart
    @POST("subida/upload")
    Call<ResponseBody> uploadFile(@Part("description") RequestBody description, @Part MultipartBody.Part file);
}

public class RetrofitService {
	private static RetrofitService INSTANCE = null;
	private static final String BASE_URL = "http://pablomonteserin.com:19139";
	private PabloAPI apiService;

	// Private constructor suppresses    
	private RetrofitService(){
		Retrofit builder = new Retrofit.Builder()
			.baseUrl(BASE_URL)
			.addConverterFactory(GsonConverterFactory.create())
			.build();

		apiService = builder.create(PabloAPI.class);
	}

	// creador sincronizado para protegerse de posibles problemas  multi-hilo
	// otra prueba para evitar instanciación múltiple
	private synchronized static void createInstance() {
		if (INSTANCE == null) {
			INSTANCE = new RetrofitService();
		}
	}

	public static RetrofitService getInstance() {
		if (INSTANCE == null) createInstance();
		return INSTANCE;
	}

	public PabloAPI getApiProxyServer(){
		return apiService;
	}
}

Servidor nodejs con Expressrouter.post('/upload', function(req, res) {
  console.log(req.files);
  console.log("amor");
  if (!req.files)
    return res.status(400).send('No files were uploaded.');
  // The name of the input field (i.e. "sampleFile") is used to retrieve the uploaded file
  let sampleFile = req.files.sampleFile;
 
  // Use the mv() method to place the file somewhere on your server
  sampleFile.mv('/usr/home/pablomonteserin/termine/public/subida/filename.jpg', function(err) {
    var path = require("path");
      console.log("./ = %s", path.resolve("./"));
      console.log("__dirname = %s", path.resolve(__dirname));

    if (err){
      console.log("adasda")
      return res.status(500).send(err);
    }
    res.send('File uploaded!');
  });
});

router.get('/', function(req, res){
	res.write(`<html>
	<body>
	<form ref='uploadForm' 
		id='uploadForm' 
		action='http://pablomonteserin.com:19139/subida/upload' 
		method='post' 
		encType="multipart/form-data">
		<input type="file" name="sampleFile" />
		<input type='submit' value='Upload!' />
		</form>     
		</body>
	</html>`);
  	res.end();
});

app.jsconst fileUpload = require('express-fileupload');
app.use(fileUpload());

Recomendación

No probar ejercicios que impliquen geolocalización en el emulador. Unos funcionan, otros no, otros funcionan mal, etc.

Geolocalización

La podemos obtener por 3 medios:

• GPS: (el más preciso y lento (puede tardar incluso más de un minuto)). 2 metros de error.
• Red móvil: El móvil detecta 3 antenas, hace un triángulo (el método se llama triangulación) y detecta la posición (con un margen de error de 20, 50 m...) depende de la distancia con las antenas. En ciudad hay menos error que en el campo. Tarda unos segundos
• Wi-Fi: Funciona si estoy conectado a una red WI-FI. El móvil detecta el SSID (nombre de la red) de la wi-fi y accede a una base de datos donde tiene registrada su ubicación.

La geolocalizacion del emulador no funciona correctamente pq no tiene ni gps, ni red movil ni han integrado la geolocalización por wi-fi.
Para falsear la geolocalización del emulador: window-> show view -> other -> emulator control
Habrá que asegurarse de tener el device seleccionado en el momento de pulsar el botón de send.

Habrá que añadir los siguientes permisos:<!--Localización usando la red WI-FI: -->
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<!--Localización usando el GPS -->
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />

Location Manager

Mostrar coordenadas en un textview

Tendremos que solicitar permisos al usuario de forma similar a como lo hicimos cuando queríamos acceder a los contactos.

ActivityCompat.requestPermissions(this,new String[]{Manifest.permission.ACCESS_FINE_LOCATION}, 1);
LocationManager lm = (LocationManager) this.getSystemService(Context.LOCATION_SERVICE);
LocationListener listener = new LocationListener(){
	...
	public void onLocationChanged(Location location) {
		textView.setText("Latitud: "+location.getLatitude()+"Longitud: "+location.getLongitude());	
	}
};

//La siguiente linea activa la geolocalizacion cada 0 milisegundos y cada 0 metros que me desplace : lo q hará realmente será darme la info con la mayor constancia posible
lm.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, listener);
//GPS_PROVIDER actualizaciones del GPS, NETWORK_PROVIDER: actualizaciones usando la red móvil
//El NETWORK_PROVIDER sólo funciona en el teléfono móvil, no en el emulador
//lm.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 0, 0,this);

OnResume, OnPause

public void onResume() {
	super.onResume();
	locationManager = (LocationManager) this.getSystemService(Context.LOCATION_SERVICE);
	locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, this);
	locationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 0, 0, this);
}

public void onPause() {
	super.onPause();
	// La siguiente línea hace que la ubicación deje de actualizarse, con lo cual se ahorra batería
	locationManager.removeUpdates(this);
}

Proximity Alert

Cuando esté cerca del punto, se lanzará una activity

LocationManager lm;

public void onCreate(){
	lm = (LocationManager) this.getSystemService(Context.LOCATION_SERVICE);
	lm.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, this);
	lm.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 0, 0,this);	
}
public void onResume() {
	…
	Intent intent = new Intent(this, LanzadaAlEstarCercaDelPunto.class);
	//El requestCode debe ser único para cada código de proximidad
	//FLAG_CANCEL_CURRENT: si hay una alerta igual a esta (tiene el mismo requestCode) la cancela
	PendingIntent pi = PendingIntent.getActivity(this, 0, intent,PendingIntent.FLAG_CANCEL_CURRENT);
	//latitud y longitud (de Madrid), radio en metros, tiempo de expiración de la alerta en milisegundos, pending intent
	lm.addProximityAlert(40.4656199, -3.6892187, 1000000, -1, pi);
}

public void onPause() {
	super.onPause();
	lm.removeUpdates(this);//Esto hace que deje de actualizarse, con lo cual se ahorra batería
}

PendingIntent
Es un envoltorio de un Intent que puede necesitar ciertos permisos para ser ejecutado. Si la aplicación dónde se está ejecutando ya tiene esos permisos, envolviendo el Intent con un PendingIntent, podremos hacer uso de dichos permisos.

Criteria

Criteria sólo funciona a partir de la API 9.

Nos permitirá determinar las características de la geolocalizacion que vamos a tratar de realizar a continuación.

Criteria crit = new Criteria();
crit.setAccuracy(Criteria.ACCURACY_COARSE);//exactitud de las mediciones. Para el método setAccuracy sólo funcionan 2 constantes ACCURACY_COARSY Y ACCURACY_FINE
crit.setPowerRequirement(Criteria.POWER_LOW); //cuanta batería va a utilizar
crit.setSpeedRequired(false); // no estamos recuperando la velocidad, así que lo podemos especificar. Es true por defecto
lm.requestLocationUpdates(0, 0, crit, pendingIntent);

Añadir un mapa

¿Qué es un fragmento?

Es una parte de una Activity, que tiene su propio ciclo de vida, recibe sus propios eventos de entrada, y que se puede añadir o quitar dinámicamente.

Añadir un mapa I (de momento, sólo el mapa, sin pasarle coordenadas)

1. Obtener una Map API Key (modo debug): https://cloud.google.com/console → Seleccionamos en la barra horizontal superior el proyecto actual y se abrirá un panel que nos permitirá crear un nuevo proyecto → Create Project → APIs → go to the api's overview → enable API → Google Maps Android API → Enable → Create Credentials → Create new Key → SHA1*;nombre del paquete dónde estará la clase que cargará el mapa en nuestro proyecto final → anotamos la API key.
2. Vista Android → Gradle Scripts → build.gradle → en dependencias añado lo siguiente: compile 'com.google.android.gms:play-services:+'
3. Además, en el layout habrá que añadir el siguiente código que representará el mapa:

   <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"/>

En el caso de que esté actualizando un proyecto viejo es probable que necesite ejecutar-> Botón derecho sobre el proyecto → Android Tools → Add Support Library (para poder usar fragmentos)

*Google Maps API v3 – es para navegadores web.

Añadir un mapa II como quedaría el AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.pablomonteserin.mapas"  android:versionCode="1" android:versionName="1.0" >
    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <uses-permission android:name="com.google.android.providers.gsf.permission.READ_GSERVICES" />
    <!-- lo que sigue es la versión del opengl mínimo que necesita el dispositivo para instalar la aplicación. Si no la tiene no le aparecerá en la google play -->
    <uses-feature android:glEsVersion="0x00020000"  android:required="true" />
    <application
        android:allowBackup="true"
        android:icon="@drawable/icon"
        android:label="@string/app_name" >
        <uses-library android:name="com.google.android.maps" />
        <activity
            android:name="com.pablomonteserin.mapas.GeolocalizacionCapasActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <meta-data
            android:name="com.google.android.maps.v2.API_KEY"
            android:value="AIzaSyDKH-mnui5hMmO3wnTdrmXy4V5IVs6KTR8" />
        <meta-data
            android:name="com.google.android.gms.version"
            android:value="@integer/google_play_services_version" />
    </application>
</manifest>

Añadir un mapa III

public class MainActivity extends AppCompatActivity implements OnMapReadyCallback {
	protected void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);
	setContentView(R.layout.activity_main);

	SupportMapFragment mapFragment  = (SupportMapFragment)getSupportFragmentManager().findFragmentById(R.id.map);
	mapFragment.getMapAsync(this);
}

Corregir posibles errores

Gradle build file"defaultConfig"... multiDexEnabled true
...
implementation 'com.android.support:multidex:1.0.3'

<uses-library android:name="org.apache.http.legacy" android:required="false" />

Centrar mapa

@Override
public void onMapReady(GoogleMap googleMap) {
	LatLng madrid = new LatLng(40.417325, -3.683081);

	CameraPosition camPos = new CameraPosition.Builder()
		.target(madrid)   //Centramos el mapa en Madrid
		.zoom(19)          //Establecemos el zoom en 19
		.bearing(45)       //Establecemos la orientación con el noreste arriba
		.tilt(70)          //Bajamos el punto de vista de la cámara 70 grados
		.build();

	CameraUpdate camUpd = CameraUpdateFactory.newCameraPosition(camPos);
	googleMap.animateCamera(camUpd);
}

Poner un marker

googleMap.addMarker(new MarkerOptions()
	.position(new LatLng(41.431725, 2.192188))
	.snippet("Tadel Formació")
	.title("Centre de formació")
	.icon(BitmapDescriptorFactory.fromResource(R.drawable.escudo)));

Geolocalización contínua con mapas

public class MyTracker implements GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener, LocationListener {
	private final String TAG = "MyAwesomeApp";

	private GoogleApiClient mGoogleApiClient;
	private LocationRequest mLocationRequest;
	private Location current_location;
	private NuevaPosicionListener listener;
    
	public MyTracker(Context context){
		mGoogleApiClient = new GoogleApiClient.Builder(context)
		.addApi(LocationServices.API)
		.addConnectionCallbacks(this)
		.addOnConnectionFailedListener(this)
		.build();
	}

	public void setListener(NuevaPosicionListener listener){
		this.listener = listener;
	}

	public void encender(){
		mGoogleApiClient.connect();
	}

	public void apagar() {
		mGoogleApiClient.disconnect();
	}

	@Override
	public void onConnected(Bundle bundle) {
		mLocationRequest = LocationRequest.create();
		mLocationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);
		mLocationRequest.setInterval(1000); // Update location every second

		LocationServices.FusedLocationApi.requestLocationUpdates(mGoogleApiClient, mLocationRequest, this);
	}

	@Override
	public void onConnectionSuspended(int i) {
		Log.i(TAG, "GoogleApiClient connection has been suspend");
	}

	@Override
	public void onConnectionFailed(ConnectionResult connectionResult) {
		Log.i(TAG, "GoogleApiClient connection has failed");
	}

	@Override
	public void onLocationChanged(Location location) {
		listener.nuevaPosicion(location);
		current_location = location;
	}
    
	public Location getCurrentLocation(){
		return current_location;
	}
}

myTracker= new MyTracker(this);
myTracker.setListener(this);
...

@Override
    protected void onStart() {
        super.onStart();
        myTracker.encender();
    }

    @Override
    protected void onStop() {
        myTracker.apagar();
        super.onStop();
    }

    @Override
    public void nuevaPosicion(Location loc) {
        myLatLng = new LatLng(loc.getLatitude(),loc.getLongitude());
        camPos = new CameraPosition.Builder()
                .target(myLatLng)	//Centramos el mapa en Madrid
                .zoom(11)			//Establecemos el zoom en 19
                .build();
        camUpd3 =  CameraUpdateFactory.newCameraPosition(camPos);
        mapa.animateCamera(camUpd3);
    }

Ejercicio

Hacer una aplicación que utilizando una base de datos SqlLite situe en pantalla 3 puntos, identificados por el logo suministrado. Al pulsar sobre el logo, iremos a una pantalla dónde se mostrará información del enclave pulsado.

Recursos:

• Logo.
• Base de datos.

Utilizaremos el HashMap tabla para que al hacer click en un marker podamos obtener su id y a continuación pasársela al siguiente activity:

@Override
public boolean onMarkerClick(Marker arg0) {
	int idMonumento = tabla.get(arg0);			
	startActivity(new Intent(this,LugarActivity.class).putExtra(MONUMENTO, monumentos.get(idMonumento)));
	return true;
}

Para recibir el monumento:
Monumento monumento = (Monumento) getIntent().getExtras().getSerializable(GeolocalizacionCapasActivity.MONUMENTO);

Obtener la ubicación de cierto lugar

String direccion = "Camino de Rubin 2, Gijón";

Geocoder geocoder = new Geocoder(this);  
List<Address> addresses;
addresses = geocoder.getFromLocationName(direccion, 1);
if(addresses.size() > 0) {
	double latitude= addresses.get(0).getLatitude();
	double longitude= addresses.get(0).getLongitude();
	tv.setText("Latitud="+latitude+" Longitud="+longitude);
}

Rutas

Debemos activar la Directions API en la sección API's overview de la Google Developer Console.

También debemos activar la facturación para esta cuenta. Ojo con todo lo que ello conlleva.

MainActivity.javapublic class MainActivity extends AppCompatActivity implements OnMapReadyCallback, TaskLoadedCallback {

    private GoogleMap mMap;
    private MarkerOptions place1, place2;
    Button getDirection;
    private Polyline currentPolyline;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_rutas);
        //27.658143,85.3199503
        //27.667491,85.3208583
        place1 = new MarkerOptions().position(new LatLng(22.3039, 70.8022)).title("Location 1");
        place2 = new MarkerOptions().position(new LatLng(23.0225, 72.5714)).title("Location 2");

        new FetchURL(MainActivity.this).execute(getUrl(place1.getPosition(), place2.getPosition(), "driving"), "driving");

        SupportMapFragment miMapa = (SupportMapFragment) getSupportFragmentManager().findFragmentById(R.id.map);

        miMapa.getMapAsync(this);
    }

    @Override
    public void onMapReady(GoogleMap googleMap) {
        mMap = googleMap;
        Log.d("mylog", "Added Markers");
        mMap.addMarker(place1);
        mMap.addMarker(place2);

        CameraPosition googlePlex = CameraPosition.builder()
                .target(new LatLng(22.7739,71.6673))
                .zoom(7)
                .bearing(0)
                .tilt(45)
                .build();

        mMap.animateCamera(CameraUpdateFactory.newCameraPosition(googlePlex), 5000, null);
    }

    private String getUrl(LatLng origin, LatLng dest, String directionMode) {
        // Origin of route
        String str_origin = "origin=" + origin.latitude + "," + origin.longitude;
        // Destination of route
        String str_dest = "destination=" + dest.latitude + "," + dest.longitude;
        // Mode
        String mode = "mode=" + directionMode;
        // Building the parameters to the web service
        String parameters = str_origin + "&" + str_dest + "&" + mode;
        // Output format
        String output = "json";
        // Building the url to the web service
        String url = "https://maps.googleapis.com/maps/api/directions/" + output + "?" + parameters + "&key=AIzaSyBKJ43pjK3x1GQjnO0zaYUwDJHdy5LiooU";
        return url;
    }

    @Override
    public void onTaskDone(Object... values) {
        if (currentPolyline != null)
            currentPolyline.remove();
        currentPolyline = mMap.addPolyline((PolylineOptions) values[0]);
    }
}

FetchURL.javapublic class FetchURL extends AsyncTask<String, Void, String> {
    Context mContext;
    String directionMode = "driving";

    public FetchURL(Context mContext) {
        this.mContext = mContext;
    }

    @Override
    protected String doInBackground(String... strings) {
        // For storing data from web service
        String data = "";
        directionMode = strings[1];
        try {
            // Fetching the data from web service
            data = downloadUrl(strings[0]);
            Log.d("mylog", "Background task data " + data.toString());
        } catch (Exception e) {
            Log.d("Background Task", e.toString());
        }
        return data;
    }

    @Override
    protected void onPostExecute(String s) {
        super.onPostExecute(s);
        PointsParser parserTask = new PointsParser(mContext, directionMode);
        // Invokes the thread for parsing the JSON data
        parserTask.execute(s);
    }

    private String downloadUrl(String strUrl) throws IOException {
        String data = "";
        InputStream iStream = null;
        HttpURLConnection urlConnection = null;
        try {
            URL url = new URL(strUrl);
            // Creating an http connection to communicate with url
            urlConnection = (HttpURLConnection) url.openConnection();
            // Connecting to url
            urlConnection.connect();
            // Reading data from url
            iStream = urlConnection.getInputStream();
            BufferedReader br = new BufferedReader(new InputStreamReader(iStream));
            StringBuffer sb = new StringBuffer();
            String line = "";
            while ((line = br.readLine()) != null) {
                sb.append(line);
            }
            data = sb.toString();
            Log.d("mylog", "Downloaded URL: " + data.toString());
            br.close();
        } catch (Exception e) {
            Log.d("mylog", "Exception downloading URL: " + e.toString());
        } finally {
            iStream.close();
            urlConnection.disconnect();
        }
        return data;
    }
}

DataParser.javapublic class DataParser {
    public List<List<HashMap<String, String>>> parse(JSONObject jObject) {

        List<List<HashMap<String, String>>> routes = new ArrayList<>();
        JSONArray jRoutes;
        JSONArray jLegs;
        JSONArray jSteps;
        try {
            jRoutes = jObject.getJSONArray("routes");
            /** Traversing all routes */
            for (int i = 0; i < jRoutes.length(); i++) {
                jLegs = ((JSONObject) jRoutes.get(i)).getJSONArray("legs");
                List path = new ArrayList<>();
                /** Traversing all legs */
                for (int j = 0; j < jLegs.length(); j++) {
                    jSteps = ((JSONObject) jLegs.get(j)).getJSONArray("steps");

                    /** Traversing all steps */
                    for (int k = 0; k < jSteps.length(); k++) {
                        String polyline = "";
                        polyline = (String) ((JSONObject) ((JSONObject) jSteps.get(k)).get("polyline")).get("points");
                        List<LatLng> list = decodePoly(polyline);

                        /** Traversing all points */
                        for (int l = 0; l < list.size(); l++) {
                            HashMap<String, String> hm = new HashMap<>();
                            hm.put("lat", Double.toString((list.get(l)).latitude));
                            hm.put("lng", Double.toString((list.get(l)).longitude));
                            path.add(hm);
                        }
                    }
                    routes.add(path);
                }
            }

        } catch (JSONException e) {
            e.printStackTrace();
        } catch (Exception e) {
        }
        return routes;
    }


    /**
     * Method to decode polyline points
     * Courtesy : https://jeffreysambells.com/2010/05/27/decoding-polylines-from-google-maps-direction-api-with-java
     */
    private List<LatLng> decodePoly(String encoded) {

        List<LatLng> poly = new ArrayList<>();
        int index = 0, len = encoded.length();
        int lat = 0, lng = 0;

        while (index < len) {
            int b, shift = 0, result = 0;
            do {
                b = encoded.charAt(index++) - 63;
                result |= (b & 0x1f) << shift;
                shift += 5;
            } while (b >= 0x20);
            int dlat = ((result & 1) != 0 ? ~(result >> 1) : (result >> 1));
            lat += dlat;

            shift = 0;
            result = 0;
            do {
                b = encoded.charAt(index++) - 63;
                result |= (b & 0x1f) << shift;
                shift += 5;
            } while (b >= 0x20);
            int dlng = ((result & 1) != 0 ? ~(result >> 1) : (result >> 1));
            lng += dlng;

            LatLng p = new LatLng((((double) lat / 1E5)),
                    (((double) lng / 1E5)));
            poly.add(p);
        }

        return poly;
    }
}

PointsParser.javapackage com.pablomonteserin.mapas.rutas2;

import android.content.Context;
import android.graphics.Color;
import android.os.AsyncTask;
import android.util.Log;

import com.google.android.gms.maps.model.LatLng;
import com.google.android.gms.maps.model.PolylineOptions;

import org.json.JSONObject;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;



public class PointsParser extends AsyncTask<String, Integer, List<List<HashMap<String, String>>>> {
    TaskLoadedCallback taskCallback;
    String directionMode = "driving";

    public PointsParser(Context mContext, String directionMode) {
        this.taskCallback = (TaskLoadedCallback) mContext;
        this.directionMode = directionMode;
    }

    // Parsing the data in non-ui thread
    @Override
    protected List<List<HashMap<String, String>>> doInBackground(String... jsonData) {

        JSONObject jObject;
        List<List<HashMap<String, String>>> routes = null;

        try {
            jObject = new JSONObject(jsonData[0]);
            Log.d("mylog", jsonData[0].toString());
            DataParser parser = new DataParser();
            Log.d("mylog", parser.toString());

            // Starts parsing data
            routes = parser.parse(jObject);
            Log.d("mylog", "Executing routes");
            Log.d("mylog", routes.toString());

        } catch (Exception e) {
            Log.d("mylog", e.toString());
            e.printStackTrace();
        }
        return routes;
    }

    // Executes in UI thread, after the parsing process
    @Override
    protected void onPostExecute(List<List<HashMap<String, String>>> result) {
        ArrayList<LatLng> points;
        PolylineOptions lineOptions = null;
        // Traversing through all the routes
        for (int i = 0; i < result.size(); i++) {
            points = new ArrayList<>();
            lineOptions = new PolylineOptions();
            // Fetching i-th route
            List<HashMap<String, String>> path = result.get(i);
            // Fetching all the points in i-th route
            for (int j = 0; j < path.size(); j++) {
                HashMap<String, String> point = path.get(j);
                double lat = Double.parseDouble(point.get("lat"));
                double lng = Double.parseDouble(point.get("lng"));
                LatLng position = new LatLng(lat, lng);
                points.add(position);
            }
            // Adding all the points in the route to LineOptions
            lineOptions.addAll(points);
            if (directionMode.equalsIgnoreCase("walking")) {
                lineOptions.width(3);
                lineOptions.color(Color.MAGENTA);
            } else {
                lineOptions.width(3);
                lineOptions.color(Color.RED);
            }
            Log.d("mylog", "onPostExecute lineoptions decoded");
        }

        // Drawing polyline in the Google Map for the i-th route
        if (lineOptions != null) {
            //mMap.addPolyline(lineOptions);
            taskCallback.onTaskDone(lineOptions);

        } else {
            Log.d("mylog", "without Polylines drawn");
        }
    }
}

Login con Google

Instalación

1. Tendremos que loguearnos en la consola de Firebase
2. Crear nuevo proyecto
3. google-services.json
   1. Engranaje de settings -> Project Settings -> Download google-services.json
   2. En Android Studio cambiamos el modo de visualización del proyecto a Proyecto.
   3. Arrastramos el fichero creado (google-services.json) sobre la carpeta APP.
4. Pegamos en el build.gradle del módulo y proyecto las líneas que nos indica el asistente de configuración.
5. Abrimos el fichero Build.gradle del módulo y copiamos el valor del applicationID. Nos vamos a la página de firebase y lo pegamos en: Engranaje de settings -> Project Settings -> Package Name.
6. Habrá que añadir los siguientes repositorios:

   build.gradle (project)allprojects {
       repositories {
           maven { url 'https://maven.google.com'  }
       }
   }

7. build.gradledependencies {
   	compile 'com.google.firebase:firebase-auth:11.4.2'
   	compile 'com.google.android.gms:play-services-auth:11.4.2'
   	...

8. Para poder recuperar datos del usuario como la contraseña, debemos ejecutar el siguiente código en nuestro ordenador:

   $ keytool -genkey -v -keystore my-key.keystore -alias alias_name -keyalg RSA -keysize 2048 -validity 10000

   y copiar el codigo SHA que genera en Consola de Firebase -> tuerquita de configuración -> Configuración del proyecto -> huella digital del certificado

Configuración

layout.xml<com.google.android.gms.common.SignInButton
	android:id="@+id/sign_in_button"
	android:layout_width="wrap_content"
	android:layout_height="wrap_content"
/>

Login.javapublic class MainActivity extends AppCompatActivity implements GoogleApiClient.OnConnectionFailedListener{ 
	private GoogleApiClient googleApiClient;
	private SignInButton signInButton;
	private int SIGN_IN_CODE;
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.login_google);

		GoogleSignInOptions gso = new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
			.requestEmail() //Esta línea es opcional, por si quiero el mail del usuario
			.build();

		googleApiClient = new GoogleApiClient.Builder(this)
			.enableAutoManage(this, this)
			.addApi(Auth.GOOGLE_SIGN_IN_API)
			.build();

		signInButton = (SignInButton) findViewById(R.id.sign_in_button);
		signInButton.setOnClickListener(new View.OnClickListener(){
			@Override
			public void onClick(View view) {
				Intent intent = Auth.GoogleSignInApi.getSignInIntent(googleApiClient);
				startActivityForResult(intent,SIGN_IN_CODE);
			}
		});
	}

	@Override
	public void onConnectionFailed(@NonNull ConnectionResult connectionResult) {}

	@Override
	protected void onActivityResult(int requestCode, int resultCode, Intent data) {
		super.onActivityResult(requestCode, resultCode, data);
		if(requestCode == SIGN_IN_CODE){
			GoogleSignInResult result = Auth.GoogleSignInApi.getSignInResultFromIntent(data);
			manejaResultado(result);
		}
	}

	private void manejaResultado( GoogleSignInResult result ){
		if(result.isSuccess()){
			Toast.makeText(this, "Exito en el Login",Toast.LENGTH_SHORT).show();
		}else{
			Toast.makeText(this, "Error en el Login",Toast.LENGTH_SHORT).show();
		}
	}

Recuperar los datos del usuario logueado con google

SecondActivity.java@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.login_google_second_activity);

        photoimageView1 = findViewById(R.id.photoImageView1);
        nombreTextView = findViewById(R.id.nombre);
        emailTextView = findViewById(R.id.email);
        id = findViewById(R.id.texto);

        GoogleSignInOptions gso = new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
                .requestEmail()
                .build();

        googleApiClient = new GoogleApiClient.Builder(this)
                .enableAutoManage(this, this)
                .addApi(Auth.GOOGLE_SIGN_IN_API, gso)
                .build();
    }

    public void desloguearse(View v){

    }

    @Override
    protected void onStart() {
        super.onStart();

        OptionalPendingResult<GoogleSignInResult> opr = Auth.GoogleSignInApi.silentSignIn(googleApiClient);
        if(opr.isDone()){
            GoogleSignInResult result = opr.get();
            manejarResult(result);
        }else {
            opr.setResultCallback(new ResultCallback<GoogleSignInResult>() {

                @Override
                public void onResult(@NonNull GoogleSignInResult googleSignInResult) {
                    manejarResult(googleSignInResult);
                }
            });
        }
    }
    private void manejarResult(GoogleSignInResult result){
        if(result.isSuccess()){
            GoogleSignInAccount account = result.getSignInAccount();
            nombreTextView.setText(account.getDisplayName());
            emailTextView.setText(account.getEmail());
            id.setText(account.getId());
        }else{
            startActivity(new Intent(this, SecondActivity.class));
        }
    }

Login con Facebook

1. Iniciamos sesión en developers.facebook.com. La documentación global está en este enlace.
2. Mis aplicaciones -> Agregar una aplicación
3. Panel -> Elegir plataforma -> Android -> Añadimos al build.gradle la dependencia que se nos indica

   compile 'com.facebook.android:facebook-android-sdk:[4,5)'

4. Pegamos Añadimos el facebook id a nuestra aplicación:

   res/values/strings.xml<string name="facebook_app_id">1508558065902615</string>

5. Modificamos el AndroidManifest.xml:

   <meta-data android:name="com.facebook.sdk.ApplicationId" android:value="@string/facebook_app_id"/>

6. Introducimos en la página web los datos que se nos solicitan y que podemos recuperar de nuestra aplicación Android.
7. Seguimos las instrucciones que se nos indican apra generar un Key Hash.

Creamos una clase que hereda de Application y que tendrá la siguiente línea en el onCreate:

AppEventLogger.activateApp(this)

Ejercicio - Dibujar un círculo

res/layout/main.xml...
<com.pablomonteserin.Vista android:layout_width="match_parent" android:layout_height="match_parent" />
...

com.pablomonteserin.Vista.javapublic class Vista extends View{
	Paint pincel;
	int color;
	public Vista(Context context){
		super(context);
		iniciar();
	}
	public Vista(Context context, AttributeSet attrs, int defStyle) {
		super(context, attrs, defStyle);
		iniciar();
	}
	public Vista(Context context, AttributeSet attrs) {
		super(context, attrs);
		iniciar();
	}

	private void iniciar(){
		pincel = new Paint();
		//Hay varias formas de definir los colores	
		//color = Color.argb(127, 0, 255, 0);
		//color = 0x7F00FF00;
		color = Color.BLUE;
		pincel.setColor(color);
		pincel.setStrokeWidth(8);
		pincel.setStyle(Paint.Style.STROKE);
	}
	protected void onDraw(Canvas canvas){
		super.onDraw(canvas);
		canvas.drawCircle(150, 150, 100, pincel);
	}
}

La clase vista debe tener tres constructores:
El primero es para crear la vista desde código. Los otros dos son para inflar la vista llamándola desde un fichero xml.

Hay que procurar no hacer ninguna instancia e incluso tener el mínimo código posible dentro del método onDraw(), ya que será llamado varias veces por segundo y relentizaría la aplicación.

Ejercicio - Dibujar un Path (trazo)

trazo y pincel son dos objetos de las clases Path y Paint respectivamente.

protected void onDraw(Canvas canvas){
	super.onDraw(canvas);
	trazo.addCircle(150, 150, 100, Path.Direction.CCW);
	pincel.setColor(Color.BLUE);
	pincel.setStrokeWidth(8);	
	pincel.setStyle(Paint.Style.STROKE);
	canvas.drawPath(trazo, pincel);
	pincel.setStrokeWidth(1);
	pincel.setStyle(Paint.Style.FILL);
	pincel.setTextSize(20);
	pincel.setTypeface(Typeface.SANS_SERIF);
	canvas.drawTextOnPath("Pablo Monteserín", trazo, 10, 40, pincel);
}

Ejercicio - Dibujar siguiendo un path II

protected void onDraw(Canvas canvas){
	super.onDraw(canvas);
	trazo.moveTo(50, 100);
	strazo.cubicTo(60, 70, 150, 90, 200, 110);
	strazo.lineTo(300, 200);
	canvas.drawColor(Color.YELLOW);
	pincel.setColor(Color.BLUE);
	pincel.setStrokeWidth(8);
	pincel.setStyle(Style.STROKE);
	canvas.drawPath(trazo, pincel);
	pincel.setStrokeWidth(1);
	pincel.setStyle(Style.FILL);
	pincel.setTextSize(20);
	pincel.setTypeface(Typeface.SANS_SERIF);
	canvas.drawTextOnPath("Pablo Monteserín", trazo, 10, 40, pincel);
}

trazo y pincel son dos objetos de las clases Path y Paint respectivamente. Sin embargo, no deben ser instanciados dentro del método onDraw(), ya que este es llamado varias veces por segundo y ralentizaría la aplicación.

Ejercicio - Dibujar un rectángulo

protected void onDraw(Canvas canvas) {
	super.onDraw(canvas);
	pincel.setColor(Color.BLUE);
	pincel.setStrokeWidth(8);
	pincel.setStyle(Paint.Style.STROKE);
	canvas.drawRect(0, 0, 200, 300, pincel);
}

Ejercicio - Dibujar un rectángulo con relleno

protected void onDraw(Canvas canvas) {
	super.onDraw(canvas);
	pincel.setColor(Color.BLUE);
	pincel.setStrokeWidth(8);
	pincel.setStyle(Paint.Style.STROKE);
	canvas.drawRect(10, 10, 200, 50, pincel);
	pincel.setColor(Color.RED);
	pincel.setStyle(Paint.Style.FILL);
	canvas.drawRect(12,12,198,48, pincel);
}

Recuperar atributos del xml

private void iniciar(Context context, AttributeSet attrs){
	pincel = new Paint();
	TypedArray attributes = context.obtainStyledAttributes(attrs, R.styleable.Monteserin_circle);
	int color = attributes.getColor(R.styleable.Monteserin_circle_monteserin_color, Color.GREEN);
	pincel.setColor(color);
}

res/values/attrs.xml<resources>
    <declare-styleable name="Monteserin_circle">
        <attr name="monteserin_color" format="color" />
    </declare-styleable>
</resources>

Definir el tamaño del Canvas

Por defecto, el tamaño de una vista si no definimos otra cosa, será todo el alto de la pantalla. Por tanto, si ponemos dos elementos seguidos, el segundo no se verá porque el primero ocupará toda la pantalla.

La solución es definir una altura específica al escribir el código en el xml, o sobreescribir el siguiente método en el archivo de la vista:

 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {

	//Estos valores definirán el tamaño de la vista
	int desiredWidth = 100;
	int desiredHeight = 50;

	int widthMode = MeasureSpec.getMode(widthMeasureSpec);
	int widthSize = MeasureSpec.getSize(widthMeasureSpec);
	int heightMode = MeasureSpec.getMode(heightMeasureSpec);
	int heightSize = MeasureSpec.getSize(heightMeasureSpec);

	int width;
	int height;

	//Measure Width
	if (widthMode == MeasureSpec.EXACTLY) {
		//Must be this size
		width = widthSize;
	} else if (widthMode == MeasureSpec.AT_MOST) {
		//Can't be bigger than...
		width = Math.min(desiredWidth, widthSize);
	} else {
		//Be whatever you want
		width = desiredWidth;
	}

	//Measure Height
	if (heightMode == MeasureSpec.EXACTLY) {
		//Must be this size
		height = heightSize;
	} else if (heightMode == MeasureSpec.AT_MOST) {
		//Can't be bigger than...
		height = Math.min(desiredHeight, heightSize);
	} else {
		//Be whatever you want
		height = desiredHeight;
	}

	//MUST CALL THIS
	setMeasuredDimension(width, height);
}

Ejercicio - Repintar con OnTouchEvent

Al pulsar sobre un rectángulo, este deberá repintarse en una posición diferente.

@Override
public boolean onTouchEvent(MotionEvent event) {
	x = event.getX();
	y = event.getY();
	//Fuerzo el repintado
	this.invalidate();
	return super.onTouchEvent(event);
}

El relleno del rectángulo crece con un click del ratón

		
protected void onDraw(Canvas canvas) {
		super.onDraw(canvas);
		pincel.setColor(Color.BLUE);
		pincel.setStrokeWidth(8);
		pincel.setStyle(Style.STROKE);
		canvas.drawRect(10, 10, getWidth(), 50, pincel);
		pincel.setColor(Color.RED);
		pincel.setStyle(Style.FILL);
		canvas.drawRect(12,12,getWidth()*this.width-3,48, pincel);
	}

	public void aumentarWidth(){
		if(this.width<1){
			this.width = (float) (this.width+0.1);
			this.postInvalidate();
		}
	}
		
	

Este método fuerza a volver a llamar al método onDraw para que el dibujo se repinte. Si no lo llamamos, el repintado no estará asegurado.

Hacer un juego sencillo

Se trata de un juego en el que un monstruo (una clase que hereda de ImageView) va cambiando de posición en la pantalla y cada vez que pulsamos sobre él aumenta un marcador.

Para realizar una tarea cada x tiempo utilizaremos:

private Handler handler;
...
handler = new Handler();
handler.postDelayed(runnable, 1000);

...
private Runnable runnable = new Runnable() {
	@Override
	public void run() {
		setRandomPosition(iv);
		handler.postDelayed(this, 1000);
	}
};

public void setRandomPosition(ImageView a1){
	int x = random.nextInt(width);
	int y = random.nextInt(height);
	a1.setX(x);
	a1.setY(y);
}

Detectar cuando se ha cargado la vista para recuperar tamaños y posiciones

@Override
public void onWindowFocusChanged(boolean hasFocus) {
	super.onWindowFocusChanged(hasFocus);
	final View content = getWindow().findViewById(Window.ID_ANDROID_CONTENT);

	view_width = content.getWidth()-a1.getWidth();
	view_height = content.getHeight()-a1.getHeight()-getStatusBarHeight();
}

public int getStatusBarHeight(){
        Rect rectangle= new Rect();
        Window window= getWindow();
        window.getDecorView().getWindowVisibleDisplayFrame(rectangle);
        int statusBarHeight = rectangle.top;
        int contentViewTop = window.findViewById(Window.ID_ANDROID_CONTENT).getTop();
        int titleBarHeight= contentViewTop - statusBarHeight;
        return statusBarHeight+titleBarHeight;
}

Publicar la aplicación en Google Play

1. Eliminamos todas las llamadas a las trazas (Log). Si no lo hacemos, la aplicación funciona pero el usuario de la misma tendría acceso a las trazas mediante logCat.
2. Android Manifest → Pestaña Application → Debuggable: false
3. Android Manifest → Pestaña Manifest → Aumentamos “Version code” y “Version Name”, según proceda.
4. Android Manifest → Pestaña AndroidManifest.xml → Cambiamos el nodo <uses-sdk android:minSdkVersion="8" /> (Buscar infor para saber en función de q)
5. AndroidManifest.xml → Pestaña Manifest → Exporting → Use the Export Wizard → Next → Create New keyStore Location: ruta en mi equipo dónde almacenaré el certificado.
   Las siguientes veces que quiera subir mi aplicación al AndroidMarket.xml utilizaré el keyStore que se me va a proporcionar. Por tanto, es importante no extraviarlo. → Next → El password requerido ahora será el mismo que el de la pantalla anterior. Validity: 25 years (por ejemplo). → Next → Indico la ruta dónde se guardará el fichero .apk del programa. → Finish → El archivo de certificado y el .apk de la aplicación son salvados en las rutas indicadas.
6. Hago las fotos (resolución 72 pixeles/inch):
   
   • feature.png (1024x500) foto que estará en la androidMarket web.
   • promo.png (la misma foto que feature.png, pero con resolución 180x120) foto que estará en la androidMarket en un dispositivo de telefonía móvil.
   • icon.png (512x512). El icono de la aplicación y que sustituirá al icon.png que por defecto coloca Android.
     También habrá que salvar el icono de android en las carpetas drawable-hdpi(72x72), drawable-mdpi(48x48), drawable-ldpi(36x36)
7. Hago un par de pantallazos de la aplicación funcionando: Arranco el emulador → voy a la pantalla de la que quiero sacar el pantallazo → voy a eclipse → window → show view → devices → selecciono el emulador → icono de screen capture
8. Vamos a https://market.android.com/publish/ y seguimos los pasos indicados.
9. Cuando lleguemos a una página con dos pestañas (Product details y APK files), debemos entrar en APK files para activar nuestro .apk subido.

Certificado de aplicaciones

Toda aplicación de Android, para poder ser desplegada debe ir firmada con un certificado.

El SDK de Android crea su propio certificado de debug, que será diferente para cada ordenador.

Por tanto si trato de instalar dos aplicaciones desde el mismo ordenador y estas tienen los mismos nombre de paquetes, para android estaré reinstalando la aplicación primera, en vez de instalando una nueva.

Por otro lado, si los certificados son diferentes pero los paquetes son iguales, obtendré un error al desplegar la aplicación.

Error típico – conflicto con el nombre del paquete repetido

Podemos cambiar el nombre del paquete en el AndroidManifest.xml de nuestro proyecto.

Eliminar una aplicación del Android Market

No es posible. Sólo es posible:

• Despublicarla (en cuyo caso mantendríamos un conflicto con los nombres de los paquetes en caso de tenerlo con la aplicación que hemos despublicado).
• Actualizarla con otra aplicación totalmente diferente. Los nombres de paquetes no deben coincidir.

Ejecutar y debugar una aplicación en el móvil

1. En el móvil: Ajustes → Aplicaciones → Desarrollo → Marco Depuración de USB.
2. Debemos tener la pestaña Devices activa (menu Window → Preferences → Show View → Other → Devices). Seleccionamos el device correspondiente a nuestro teléfono móvil (que debe estar conectado al ordenador).

No puedo instalar dos aplicaciones que utilicen los mismos nombre de paquetes.
Para poder hacerlo debo desinstalar la que ya tengo instalada, o cambiar el nombre del paquete.

Desinstalar una aplicación del teléfono móvil desde consola

Habrá que hacerlo cuando hayamos instalado la aplicación y queramos volver a instalarla sobrescribiendo la vieja aplicación.

/android-sdk-linux_x86/platform-tools$ ./adb uninstall com.pablomonteserin