Curso de Android

ANDROID

Es un S.O. basado en linux y escrito en Java.

Versiones de Android

Guía de instalación

1. Instalación del JDK:
   http://www.oracle.com/technetwork/java/javase/downloads/index.html
2. Instalación de Android Studio:
   http://developer.android.com/sdk/index.html

Activar opciones de desarrollo en Android 4.0 y superiores

Ajustes → Acerca del teléfono → Pulsamos 7 veces sobre el número de compilación.

Problema con la versión de Gradle

The version of Gradle you are using (Gradle installation '...') does not support ... Support for this is available in Gradle ... and all later versions.

Habrá que instalar la última versión de Gradle: gradle.org. Si somos usuarios de linux, debemos instalar el gestor de versiones sdkman.

Ejecutar aplicaciones desde el móvil

Esto será mucho más rápido y veraz que ejecutar desde el emulador.

En la pestaña Devices veremos el ordenador está reconociendo el dispositivo. Si no lo reconoce (muestra ???????????), es probable que debamos instalar los drivers.

Android API

http://developer.android.com/index.html → Develop → Reference

http://developer.android.com/reference/packages.html

Primer proyecto

File → new → Android → Android Proyect → Create new proyect in Workspace → Lo llamamos a_hola_mundo

Esto crea un proyecto Android con un Activity que será el punto de inicio de la aplicación.

Error típico: An SDK Target must be specified → Para solventarlo → window → preferences → Android

Activity

Es una clase java. Presenta su propia interfaz de usuario (ventana).

Es cada una de las pantallas que componen una aplicación.

Uno de los activities es el que lanza la aplicación (lanzador)

Hola Mundo - Activity

Este es el código del Activity que se genera por defecto al crear nuestro proyecto.

		
public class A_holaMundoActivity extends Activity{
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }
}
		
	

R (resources) es una clase java (ruta gen/R.java) que contiene constantes que apuntan a la ubicación de los recursos utilizados en nuestra aplicación.

R.layout.main contiene la ubicación del XML que contiene la apariencia de nuestra activity. Está accesible desde res/layout/main.xml. En eclipse, será posible modificar dicha ubicación mediante un editor gráfico o mediante código.

Algunos atajos útiles del teclado para el emulador

Esc: back
F2: menu
Ctrl + F12 Cambiar orientación

Hola Mundo - Layout

Por defecto, la propiedad android:text del main.xml apunta a una variable hello, definida en res/values/string.xml que contiene su valor. También podría haber puesto directamente el texto “Hola Mundo”, en vez de una constante.

	
main.xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >
<TextView  
    android:layout_width="fill_parent" 
    android:layout_height="wrap_content" 
	android:text="@string/hello"

    />
</LinearLayout>

string.xml
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="hello">Hello World, A_holaMundoActivity!</string>
    <string name="app_name">A_holaMundo</string>
</resources>
	

Unidades de medida

• sp: scale-independent pixels. Es similar a la unidad dp, pero su tamaño variará dependiendo de las preferencias del usuario y de la densidad de la pantalla. Lo utilizarás para los tamaños de textos.
• dip: density-independent pixels. Lo utilizarás para todo lo demás. Un dip es lo mismo que un dp, habitualmente utilizamos el término dp, porque se parece más al término sp. Estas unidades son relativas a una pantalla de 160 dpi(dots per inch); luego un dp equivale a un px en este tipo de pantalla.
• px: pixel
• in: inches (pulgadas). Basadas en el tamaño físico de la pantalla.
• mm: milímetros. Basados en el tamaño físico de la pantalla.
• pt: points. 1/72 de una pulgada.

Ejercicio Layout

Hacer una aplicación con un activity que llame a un layout llamado nuevo_layout.xml que tenga dos cuadros de texto.

En el primero se muestra el texto “Hola Mundo”. Dicho texto será una variable definida en strings.xml. Se mostrará en un tamaño superior al normal.

En el segundo se muestra el texto “Adios Mundo”. Dicho texto estará escrito directamente en la propiedad android:text. Se mostrará en rojo y en negrita.

Probar a introducir otros componentes, modificar sus propiedades y ver el efecto que esto tiene

Crear una interfaz de usuario por código

		
public class A_interfazUSuarioActivity extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        TextView texto = new TextView(this);
        texto.setText("Hola Mundo");
        setContentView(texto);
    }
}
		
	

Un contexto es un manejador del sistema que proporciona servicios como acceso a bases de datos, etc.

La clase Activity es una subclase de Context.

Al instanciar un objeto de la clase TextView le pasamos como parámetro el Activity que se va a encargar de gestionarlo.

Al instanciar un objeto de la clase TextView le pasamos como parámetro el Activity que se va a encargar de gestionarlo.

Como la clase A_interfazUSuarioActivity es una subclase de Activity, también es de tipo context. Por ello, puedes pasar this como contexto del TextView.

Tipos de layout

• Linear Layout
  Para definir si los elementos se irán apilando verticalmente u horizontalmente:

  
  <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  android:orientation=vertical android:layout_width="fill_parent" android:layout_height="fill_parent">
  </LinearLayout>
  

• Nota: Si tenemos algún elemento con su alto o ancho ocupando toda la pantalla o unas dimensiones demasiado grandes, los elementos desaparecerán por la derecha o el fondo de la pantalla.
• RelativeLayout
  Los elementos se posicionan en función de los que tienen al lado.
• FrameLayout
  Los elementos se superponen unos con otros. No es un layout típico.
• TableLayout
  Coloca los elementos siguiendo una distribución de tabla
• AbsoluteLayout
  Deprecated

Linear Layout (el más frecuente)

	
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
  xmlns:android="http://schemas.android.com/apk/res/android"
  android:orientation="vertical"
  android:layout_width="match_parent"
  android:layout_height="match_parent">
	<AnalogClock 
		android:layout_width="wrap_content"
		android:layout_height="wrap_content" />
	<CheckBox
		android:layout_width="wrap_content"
		android:layout_height="wrap_content"
		android:text="un checkbox" />
	<Button
		android:layout_width="wrap_content"
		android:layout_height="wrap_content" 
		android:text="un botón" />
	<TextView
		android:layout_width="wrap_content"
		android:layout_height="wrap_content"
		android:text="un TextView" />
</LinearLayout>
	

Table Layout

Se utiliza la etiqueta TableRow cada vez que queremos insertar una nueva línea.
Utilizaré el atributo android:stretchColumns="*" para que las celdas ajusten su tamaño hasta alcanzar los límites de la pantalla.

	
<?xml version="1.0" encoding="utf-8"?>
<TableLayout
  xmlns:android="http://schemas.android.com/apk/res/android"
  android:orientation="vertical"
  android:layout_width="match_parent"
  android:layout_height="match_parent">
<TableRow>
	<AnalogClock 
	android:layout_width="wrap_content"
	android:layout_height="wrap_content" />
	<CheckBox
	android:layout_width="wrap_content"
	android:layout_height="wrap_content"
	android:text="un checkbox" />
</TableRow>
<TableRow>
	<Button
	android:layout_width="wrap_content"
	android:layout_height="wrap_content" 
	android:text="un botón" />
	<TextView
	android:layout_width="wrap_content"
	android:layout_height="wrap_content"
	android:text="un TextView" />
</TableRow>
</TableLayout>
	

GridLayout

		
<GridLayout
  xmlns:android="http://schemas.android.com/apk/res/android"
  android:layout_width="match_parent"
  android:layout_height="match_parent"
      android:columnCount="2">
<AnalogClock 
android:layout_width="wrap_content"
android:layout_height="wrap_content" />
<CheckBox
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/un_checkbox" />
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content" 
android:text="@string/un_boton" />
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/un_textview" />
</GridLayout>
		
	

Relative Layout
permite comenzar a situar los elementos en cualquiera de los cuatro lados del contenedor e ir añadiendo elementos pegados a estos

	
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout
  xmlns:android="http://schemas.android.com/apk/res/android"
  android:orientation="vertical"
  android:layout_width="match_parent"
  android:layout_height="match_parent">
<AnalogClock 
android:id="@+id/AnalogClock01"
android:layout_width="wrap_content"
android:layout_height="wrap_content" 
android:layout_alignParentTop="true"/>
<CheckBox
android:id="@+id/CheckBox01"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="un checkbox" 
android:layout_below="@+id/AnalogClock01"/>
<Button
android:id="@+id/Button1"
android:layout_width="wrap_content"
android:layout_height="wrap_content" 
android:text="un botón" 
android:layout_below="@+id/CheckBox01"/>
<TextView
android:id="@+id/TextView01"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentBottom="true"
android:text="un TextView" />
</RelativeLayout>

	

Frame Layout (posiciona todos los elementos usando todo el contenedor, sin distribuirlos espacialmente)

	
<?xml version="1.0" encoding="utf-8"?>
<FrameLayout
  xmlns:android="http://schemas.android.com/apk/res/android"
  android:orientation="vertical"
  android:layout_width="match_parent"
  android:layout_height="match_parent">
<AnalogClock 
android:layout_width="wrap_content"
android:layout_height="wrap_content" />
<CheckBox
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="un checkbox" />
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content" 
android:text="un botón" />
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="un TextView" />
</FrameLayout>

	

fill_parent, match_parent y wrap_content

Nota: en algunos ejemplos es posible que veamos fill_parent en vez de match_parent.

Realmente son la misma cosa, pero a partir de la API 8 se introdujo el término match_parent y ese es el que debe usarse.

Ejercicio Linear Layout

Utilizaremos un Linear Layout y setearemos su propiedad gravity.

El fichero res/strings.xml ha de tener el siguiente contenido:

	
<?xml version="1.0" encoding="utf-8"?>
<resources>
	<string name="app_name">Ejercicio Layout</string>
	<string name="pablomonteserin">Pablo Monteserín</string>
	<string name="menu1">Acerca de mí</string>
	<string name="menu2">Galería de videos</string>
	<string name="menu3">Galería de fotos</string>
	<string name="menu4">Contacto</string>
</resources>
	

Ejercicio TableLayout

Android permite diseñar una vista diferente para la configuración horizontal y vertical.

A partir del ejercicio anterior, crea la carpeta res/layout-land y crea en ella una vista con el mismo nombre que la que está en la carpeta layout.

Para ver la carpeta land recién creada: panel Project → Packages.

Para cambiar la orientación de la pantalla podremos pulsar ctrl+F12

Habrá que usar un TableLayout dentro de un LinearLayout. Para el tableLayout utilizar el siguiente atributo: android:stretchColumns="*". Este estira todas (*) las columnas para ocupar el ancho de la pantalla.

Todos los elementos visuales del layout deben tener un layout_width y un layout_height; los layouts, los Buttons y el TextView

Ejercicio – strings.xml e internalizacion

Android utiliza una lista de sufijos para expresar recursos alternativos. Estos sufijos pueden hacer referencia a la orientación del dispositivo, al lenguaje, la región, la densidad de pixeles, la resolución, etc.

Para ver la lista de sufijos, al pulsar ctrl +n → Android XML values File → next → seleccionamos el qualifer (sufijo)

Crea el siguiente fichero en el que traducirás todas las cadenas al inglés:
res/values-en/strings.xml

Para cambiar el idioma en el dispositivo:
Ajustes → Idioma y texto → Seleccionar idioma

Contenido scrollable

Bastará con envolver el Layout dentro de nuestro activity_main.xml por un ScrollView. El ScrollView sólo puede tener un hijo.

Nota:
No pondremos un ListView dentro de un ScrollView salvo que no nos quede mas remedio, ya que ambos componentes son engorrosos de integrar.

AndroidManifest.xml

Describe las funcionalidades y los permisos que serán necesarios, etc. de la aplicación.
Para editarlo recurriremos a las vistas xml y no a las vistas gráficas que nos da eclipse.
Las siguientes líneas estarán contenidas en el nodo del activity que se lanzará en primer lugar al arrancar la aplicación:

	
<intent-filter>
	<action android:name="android.intent.action.MAIN" />
      <category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
	

Cuando en la consola de trazas obtengo un "Class Not Found Exception":
o el nombre de la clase o el nombre del paquete están mal en el manifest. Lo ideal es que en el manifest la definición del paquete coincida con el paquete raíz de todos los activities.

Si tenemos el siguiente error en las trazas:
android.content.ActivityNotFoundException: Unable to find explicit activity class {com.pablomonteserin/com.pablomonteserin.Second}; have you declared this activity in your AndroidManifest.xml?

Falto declarar la segunda activity. Ponemos la siguiente línea en el AndroidManifest.xml

	
<activity android:name=".Second" />
	

R

Todos los recursos (xml, drawable, etc.) se empaquetan en un archivo R que es una especie de índice de recursos.

android:id="@+id/item2"

La arroba significa que nos estamos refiriendo al archivo de recursos R.
El + significa que estamos añadiendo un nuevo recurso.

Cada vez q realizo un cambio en la estructura de mi proyecto (carpetas, documentos xml, atributos de dichos documentos, etc) android lo comprueba. Si el cambio arrojase un error es probable que dicho error apareciese reflejado en la pestaña Console

Imágenes

Tamaños de imágenes y layouts en función de la pantalla dónde serán reproducidos

	
res/drawable-mdpi/my_icon.png 		//bitmap for medium density
res/drawable-hdpi/my_icon.png 		//bitmap for high density
res/drawable-xhdpi/my_icon.png 		//bitmap for extra high density

res/layout/my_layout.xml 			//layout for normal screen size (“default”)
res/layout-small/my_layout.xml 		//layout for small screen size
res/layout-large/my_layout.xml 		//layout for large screen size
res/layout-xlarge/my_layout.xml 		//layout for extra large screen size
res/layout-xlarge-land/my_layout.xml 	//layout for extra large in landscape orientation
	

Ponemos los recursos en estas carpetas y será el sistema el que decida cuál utilizar.

Ejercicio - Cargar una imagen

Debemos copiar la imagen en la carpeta drawable-hdpi.

Cargar la imagen en un ImageView:
Introducimos un objeto de tipo ImageView en el xml y lo vinculamos a la imagen guardada en drawable.

Cargar la imagen en un ImageButton:
Introducimos un elemento de tipo ImageButton en el xml y lo vinculamos a la imagen guardada en drawable.

Cambiar dinámicamente la foto del ImageView anterior:

	
ImageView iv = (ImageView) findViewById(R.id.imageView1);
iv.setImageResource(R.drawable.cara);
	

Background repeat

Por defecto una imagen se deformará para ocupar las dimensiones del ImageView, en el caso de que la imagen sea mas pequeña. Si lo que queremos es que la imagen se repita:

	
activity_main.xml
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:background="@drawable/background_repeat
...

background_repeat.xml
<?xml version="1.0" encoding="utf-8"?>
<bitmap xmlns:android="http://schemas.android.com/apk/res/android" 
   android:src="@drawable/icon"
   android:tileMode="repeat"
    />
	

Consola de trazas

Poner nuestras propias trazas:

		
Log.d("total", cadenaTexto);
	
	

Si quiero mostrar por las trazas un número:

	
Log.d("total", ""+numeroRegistros);
	

Para ver las trazas:
Window → show view → other → logcat, devices (debo seleccionar el dispositivo del que quiero ver las trazas)

AndroidManifest.xml → Debbuggable: true

Ejercicio - Hacer que un radio button pertenezca a un RadioGroup para que no pueda haber dos seleccionados simultáneamente.

	
<RadioGroup android:layout_width="fill_parent" android:layout_height="wrap_content">
	<RadioButton android:text="RadioButton" android:id="@+id/radioButton1" android:layout_width="wrap_content" android:layout_height="wrap_content"></RadioButton>
	<RadioButton android:text="RadioButton" android:id="@+id/radioButton2" android:layout_width="wrap_content" android:layout_height="wrap_content"></RadioButton>
	<RadioButton android:text="RadioButton" android:id="@+id/radioButton3" android:layout_width="wrap_content" android:layout_height="wrap_content"></RadioButton>
	<RadioButton android:text="RadioButton" android:id="@+id/radioButton4" android:layout_width="wrap_content" android:layout_height="wrap_content"></RadioButton>
</RadioGroup>
	

Radiogroup es un layout, y como ocurre con todos los layouts, habrá que definir su ancho y alto.

Ejercicios estilos

Ejercicio - Cambiar dinámicamente el color o la imagen de fondo de un layout

	
milayout= findViewById(R.id.miLayout); 
milayout.setBackgroundColor(Color.rgb(151, 19, 19)); 
//milayout.setBackgroundResource(R.drawable.background_img);
	

Ejercicio - Poner un degradado a un layout

res/drawable/degradado.xml

	
<?xml version="1.0" encoding="utf-8"?>
<shape
  xmlns:android="http://schemas.android.com/apk/res/android">
	<gradient android:startColor="#FFFFFF"
	android:endColor="#0000FF"
	android:angle="270"/>    
</shape>
	

En el .java

	
View mlayout = findViewById(R.id.main_layout);
mlayout.setBackgroundResource(R.drawable.degradado);
	

Ejercicio - Maquetar un botón

res/drawable/rect.xml

		
<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android"
	android:shape="rectangle">
	<gradient
		android:startColor="#FFFF0000"
		android:endColor="#80FF00FF"
		android:angle="45"/>
	<!--  Este es el padding para colocar el texto -->
	<padding
		android:left="7dp"
		android:top="7dp"
		android:right="7dp"
		android:bottom="7dp" />		
	<corners android:radius="10dp" />
</shape>


main.xml
<Button android:text="Button" android:id="@+id/button1" android:layout_width="wrap_content" android:layout_height="wrap_content" android:background="@drawable/rect" />

		
	

main.xml

	
<Button android:text="Button" android:id="@+id/button1" android:layout_width="wrap_content" android:layout_height="wrap_content" android:background="@drawable/rect" />
	

Ejercicio – usar colores predefinidos

rest/layout/main.xml

	
<TextView  
    android:layout_width="fill_parent" 
    android:layout_height="wrap_content" 
    android:text="@string/hello"
    android:textSize="30dp"
    android:textColor="@>colorred"
    />
	

res/values/loquesea.xml (también podría modificar el styles.xml)

	
<?xml version="1.0" encoding="utf-8"?>
<resources>
	<color name="red">#ff0000</color>
	<color name="green">#00ff00</color>
	<color name="blue">#0000ff</color>
</resources>
	

Ejercicio - Cargar las propiedades de un elemento desde un xml

Creamos el xml:
New → Android XML file → what type of resource would you like to create? → Values

res/layout/main.xml
<TextView  
    android:layout_width="fill_parent" 
    android:layout_height="wrap_content" 
    android:text="@string/hello" 
    style="@style/code"/>
	

res/values/loquesea.xml (también podría modificar el styles.xml)
<?xml version="1.0" encoding="utf-8"?>
<resources>
	<style name="code" parent="@android:style/TextAppearance">
		<item name="android:textSize">40sp</item>
		<item name="android:typeface">monospace</item>
		<item name="android:textColor">#0000FF</item>
	</style>    
</resources>
	

Ejercicio - crear un estilo que sobrescriba el anterior.

res/layout/loquesea.xml
<TextView 
    android:text="TextView" 
    android:id="@+id/textView1" 
    style="@style/code.red" 
    android:layout_width="wrap_content" 
    android:layout_height="wrap_content"></TextView>
	

res/values/loquesea.xml
<?xml version="1.0" encoding="utf-8"?>
<resources>
	<style name="code" parent="@android:style/TextAppearance">
			<item name="android:textSize">40sp</item>
			<item name="android:typeface">monospace</item>
			<item name="android:textColor">#0000FF</item>
	</style>
	<style name="code.red">
		<item name="android:textColor">#FF0000</item>
	</style>    
</resources>	
	

Ejercicio – Cargar un theme de los que vienen por defecto en android

Para aplicar un theme a toda la aplicación añado la línea en rojo en el AndroidManifest.xml:

		
<application android:icon="@drawable/icon" android:label="@string/app_name"
android:theme="@android:style/Theme.Dialog">	
		
	

Para aplicarlo a un activity en concreto:

	
<activity android:name=".AcercaDe"
	android:label="@string/app_name"
	android:theme="@android:style/Theme.Dialog">
</activity>
	

Puedo ver cómodamente los themes disponibles desplegando la combo correspondiente en el layout.xml

Ejercicio → Cargar mi propio theme

New → Android XML file → what type of resource would you like to create? → Values

	
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <style parent="@android:style/Theme.Dialog" name="myTheme">
    	<item name="android:textColor">#FF0000</item>
    </style>
</resources>
	

Cargamos el theme creado por nosotros utilizando el código pintado de rojo en el AndroidManifest.xml:

	
<application android:icon="@drawable/icon" android:label="@string/app_name"
android:theme="@style/myTheme">
	

Ejercicio

Crear un theme que herede de Theme.Dialog y hacer que toda la aplicación lo implemente.

El tema tendrá los siguientes estilos:

	
android:textColor="#00FF00"
android:typeface="monospace"
	

Iconos

Recomendaciones sobre cómo hacer los iconos en Android: http://developer.android.com/guide/practices/ui_guidelines/icon_design.html

Arreglar redimensionamientos de fotografías

En el caso de un botón con esquinas redondeadas, no querré que las esquinas se deformen. Por tanto haré que las esquinas no caigan dentro del área sombreada (en verde o rosa).

El área sombreada en verde se redimensiona en una dimensión.
El área sombreada en rosa se redimensiona en dos dimensiones.

Carpeta de Android → tools → draw9patch → Arrastramos la imagen que queremos tratar adentro del área con la flecha → desmarcamos la casilla “show lock” → marco la check de “show patches” → en los bordes de la imagen aparece una zona transparente, llevo el cursor hacia allí.

Pulsando shift elimino área sombreada.

Finalmente salvo la imagen en la carpeta de imágenes de mi proyecto.

Dibujar

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.java
public 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.BLUE;
		//color = Color.argb(127, 0, 255, 0);
		//color = 0x7F00FF00;
		color = getResources().getColor(R.color.color_circulo);
		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);
	trazoaddCircle(150, 150, 100, Direction.CCW);
	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);
}
		
	

Ejercicio - Dibujar siguiendo un path II

protected void onDraw(Canvas canvas){
	super.onDraw(canvas);
	trazo.moveTo(50, 100);
	trazo.cubicTo(60, 70, 150, 90, 200, 110);
	trazo.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(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(Style.STROKE);
	canvas.drawRect(10, 10, 200, 50, pincel);
	pincel.setColor(Color.RED);
	pincel.setStyle(Style.FILL);
	canvas.drawRect(12,12,198,48, pincel);
}
	

Repintar con OnTouchEvent

	
public class Vista extends View {
	private float x;
	private float y;
…
//Los tres constructores
@Override
	protected void onDraw(Canvas canvas) {
		super.onDraw(canvas);
		pincel.setColor(Color.BLUE);
		pincel.setStrokeWidth(8);
		pincel.setStyle(Style.STROKE);
		canvas.drawRect(x+10, y+10, x+200, y+50, pincel);
	}
	@Override
	public boolean onTouchEvent(MotionEvent event) {
		x = event.getX();
		y = event.getY();
		//Fuerzo el repintado
		this.invalidate();
		return super.onTouchEvent(event);
	}
	

OnClick

	
MainActivity.java
public class MainActivity extends Activity {
	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
	}
	public void btnPulsado(View v){
		TextView tv = (TextView)findViewById(R.id.textView1);
		tv.setText("botón pulsado");
	}
}

main.xml
…
<Button android:text="Button" android:id="@+id/button1" android:layout_width="wrap_content" android:layout_height="wrap_content" android:onClick="btnPulsado"></Button>
...
	

Esta forma de gestionar los eventos fue introducida en la API 7 (Android 2.1)

Implementación de la interfaz OnClickListener()

Con esto conseguiremos tener solamente una única clase que gestione todos los eventos de click.

	
public class Main extends Activity implements View.OnClickListener{
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
        Button b = (Button) findViewById(R.id.button1);
        b.setOnClickListener(this);
    }
	@Override
	public void onClick(View v) {
		if(v.getId() ==  R.id.button1){
			Log.d("traza", "llega");
		}
	}
}
	

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.

Clase OnClickListener (lo utilizaremos para el siguiente ejercicio)

	
Button b = (Button) findViewById(R.id.button1);
b.setOnClickListener(new View.OnClickListener() {
@Override
	public void onClick(View arg0) {
		Toast.makeText(getApplicationContext(), "Boton Pulsado",Toast.LENGTH_LONG).show();
	}
});
	

Añadir un nuevo Activity

Botón derecho sobre el paquete → new → class → Android Activity

Esto crea una clase Activity con su método onCreate y su correspondiente referencia en el AndroidManifest.xml.

¿Para qué sirve un Intent?

Para invocar componentes (un Activity, código ejecutándose en segundo plano, et.)

Crear un botón en la primera activity para que cuando pulsemos sobre él vayamos a la segunda

		
	package com.pablomonteserin;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;

public class Main extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
        Button b = (Button) findViewById(R.id.button1);
        
        b.setOnClickListener(new OnClickListener(){
        	public void onClick(View v){
        		startActivity(new Intent(Main.this, Second.class));
        	}
   });}}
		
	

Activity que hace la llamada. Si sólo ponemos this, se pensará que estamos haciendo referencia a la clase OnClickListener, en lugar de a la clase Main

Hay que registrar el Activity en el AndroidManifest.xml

	
<activity android:name=".AcercaDe" 
	android:label="@string/app_name">
</activity>
	

Ejercicio

Hacer que al pulsar el botón Acerca de se lance un activity con un cuadro de texto informativo.

El activity con el cuadro informativo utilizará un theme propio de diálogos:

	
android:theme="@android:style/Theme.Dialog"
	

Dicho Activity deberá extender de la clase Activity, en lugar de la clase ActionBarActivity.

Pasar información de una activity a otra

		
Main.java
	public final static String TEXTO = "texto";

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

	public void pasarInfo(View view) {
		final EditText et = (EditText) findViewById(R.id.editText1);
		Intent intent = new Intent(Main.this, Second.class);
		intent.putExtra(TEXTO, et.getText().toString());
		startActivity(intent);
	}

Second.java
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.second);
		TextView tv = (TextView)findViewById(R.id.textView1);
		tv.setText(getIntent().getExtras().getString(Main.TEXTO));
	}

		
	

Menus

Ejercicio - Crear un menú

Un menú contextual es lanzado al pulsar la tecla menú del teléfono.

	
Menu.xml
<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
	<item android:id="@+id/item1" android:title="Option 1" android:icon="@android:drawable/ic_menu_compass" />
	<item android:id="@+id/item2" android:title="Option 2" android:icon="@android:drawable/ic_menu_call" />    
</menu>
-------------------------------------------------------------------------------------------------
MenuActivity.java
public class MenuActivity extends Activity {
	...
	@Override
	public boolean onCreateOptionsMenu(Menu menu) {
		MenuInflater inflater = getMenuInflater();
		inflater.inflate(R.menu.menu, menu);
		return true;
	}
	

Al ejecutar la aplicación pulsamos el botón de menú para ver los menús.

Ejercicio - Detectar la pulsación de un menú

Añadimos el siguiente código al java anterior:

	
public boolean onOptionsItemSelected(MenuItem item){
	if(item.getItemId() == R.id.item1){
    	Log.d("opcion", "opcion 1 pulsada");
    }
	return super.onOptionsItemSelected(item);
}
	

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

Necesitamos este código para el ejercicio siguiente

		
@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;
}
		
	

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:

	
timer = new Timer();
task = new MyTimerTask();
timer.schedule(task, 0, 1000);
	

	
private class MyTimerTask extends TimerTask {
	/*  En Android hay una restricción con respecto al hilo que pinta la pantalla. Para  modificarlo desde fuera del método onDraw de la clase View utilizo el método runOnUiThread. */
	@Override
	public void run() {
		MainActivity.this.runOnUiThread(new Runnable() {
			public void run() {
			setRandomPosition(a1);
        }
    });
    }
}

public void setRandomPosition(ImageView a1){
	int x = randInt(a1.getWidth(), view_width);
	int y = randInt(a1.getHeight(), view_height);
	a1.setX(x);
	a1.setY(y);
}
	

Problema al cambiar la orientación de la pantalla

Al cambiar la orientación se destruyen los componentes visuales y se vuelven a crear, llamando al onCreate.

Podemos solventar los problemas que esto pueda acarrear modificando el nodo <activity> correspondiente del AndroidManifest.xml:

- Para limitar el giro de la aplicación:
android:screenOrientation="portrait"

- Para que no se destruya el activity:
android:configChanges="keyboard|keyboardHidden|orientation|screenSize|smallestScreenSize"

Ejercicio – Al pulsar sobre un botón, convertir una imagen en otra

	
MainActivity.java
public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        Button b = (Button) findViewById(R.id.button1);
        b.setOnClickListener(this);
    }

	@Override
	public void onClick(View arg0) {
		if(arg0.getId()==R.id.button1){
			ImageView iv = (ImageView) findViewById(R.id.imageView1);
			TransitionDrawable td = (TransitionDrawable) iv.getDrawable();
			td.startTransition(1000);
		}
	}

res/drawable-hdpi/transition.xml
<?xml version="1.0" encoding="utf-8"?>
<transition
  xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:drawable="@drawable/steve1"></item>
    <item android:drawable="@drawable/steve2"></item>
</transition>
	

En el layout, el ImageView deberá tener el siguiente atributo: android:src="@drawable/transition"

Ejercicio

Al pulsar sobre un botón, animarlo utilizando la clase Tween, que se encargará de deformarlo.

	

MainActivity.java
…
Animation anim = AnimationUtils.loadAnimation(AnimationTweenActivity.this, R.anim.animation);
Button b = (Button)findViewById(R.id.button1);
b.startAnimation(anim);
…

res/anim/animation.xml
<?xml version="1.0" encoding="utf-8"?>
<scale xmlns:android="http://schemas.android.com/apk/res/android"
	android:fromXScale="0.5"
	android:toXScale="2.0"
	android:fromYScale="0.5"
	android:toYScale="2.0"
	android:pivotX="50%"
	android:pivotY="50%"
	android:duration="4000"
	  >
</scale>
	

Si quiero iniciar las dos animaciones a la vez, lo pondre a 0.

Ejercicio - set de animaciones

	
<?xml version="1.0" encoding="utf-8"?>
<set xmlns:android="http://schemas.android.com/apk/res/android">
	<scale xmlns:android="http://schemas.android.com/apk/res/android"
	 	android:fromXScale="0.5"
	 	android:toXScale="2.0"
	 	android:fromYScale="0.5"
	 	android:toYScale="2.0"
	 	android:pivotX="50%"
	 	android:pivotY="50%"
	 	android:duration="4000" />
	<rotate android:fromDegrees="0"
		android:toDegrees="180"
		android:pivotX="50%"
		android:pivotY="50%"
		android:duration="20000"
		android:startOffset="2000" />
</set>
	

Detectar el fin de una animación

El activity debe implementar la interfaz AnimationListener.

	
...
questionsPanel_anim.setAnimationListener(this);
questionsPanel.startAnimation(questionsPanel_anim);	
...


public void onAnimationEnd(Animation arg0) {
		if(arg0==questionsPanel_anim){
			pintarPreguntasYRespuestas();
		}
}
	

Animación FrameByFrame

		
MainActivity.java
…
ImageView iv = (ImageView) findViewById(R.id.imageView1);
iv.setBackgroundResource(R.drawable.animation);
AnimationDrawable animation = (AnimationDrawable) iv.getBackground();
animation.start();

res/layout/activity_main.xml
<ImageView
    android:background="@drawable/animation"
    ...
/>

res/drawable/animation.xml
<animation-list xmlns:android="http://schemas.android.com/apk/res/android">
<item android:drawable="@drawable/animation_00031" android:duration="30" />
<item android:drawable="@drawable/animation_00032" android:duration="30" />
<item android:drawable="@drawable/animation_00033" android:duration="30" />
…
		
	

Preferencias

Las usamos para guardar pequeñas cantidades de información.

Suelen ser datos que una aplicación debe guardar para personalizar la experiencia del usuario, por ejemplo información personal, opciones de presentación, etc.

La información es almacenada en forma clave-valor en ficheros xml, en el dispositivo móvil:
/data/data/paquetejava/shared_prefs/nombre_coleccion.xml

Ver las preferencias del emulador

Para acceder a las shared preferences del dispositivo pulsamos en el Android Device Monitor (robot verde de la toolbar) → pestaña File Explorer

/data/data/com.pablomonteserin/shared_prefs/
com.pablomonteserin_preferences.xml

Guardar preferencias

		
public class Almacenamiento_Pref_Activity extends Activity {
	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);

		SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
		String txt = sp.getString("texto", "valor por defecto");
		Toast.makeText(getApplicationContext(), txt, Toast.LENGTH_LONG).show();
	}
	
	//El siguiente código se ejecuta cuando la aplicación está a punto de terminar
	@Override 
	protected void onPause() {
		super.onPause();
		EditText et = (EditText)findViewById(R.id.editText);
		SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
		SharedPreferences.Editor sharedPreferencesEditor = sp.edit();
		sharedPreferencesEditor.putString("texto", et.getText().toString());
		sharedPreferencesEditor.commit();
	}
		
	

Si pulso el botón de retroceso volveré al menú principal, pero la información introducida estará disponible la próxima vez que ejecute la aplicación.

XML de preferencias

		
res/xml/preferences.xml
<?xml version="1.0" encoding="utf-8"?>
<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android">
    <CheckBoxPreference android:key="primero" android:title="Opción 1" android:summary="Descripción opción 1" />
    <CheckBoxPreference android:key="segundo" android:title="Opción 2" android:summary="Descripción opción 2" />
</PreferenceScreen>
		
	

¿Qué es un fragmento?

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

Preferencias con Fragment

	
public class MainActivity extends Activity {
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		getFragmentManager().beginTransaction()
				.replace(android.R.id.content, new PreferenciasFragment()).commit();
	}
	public static class PreferenciasFragment extends PreferenceFragment {
		@Override
		public void onCreate(Bundle savedInstanceState) {
			super.onCreate(savedInstanceState);

			// Make sure default values are applied. In a real app, you would
			// want this in a shared function that is used to retrieve the
			// SharedPreferences wherever they are needed.
			PreferenceManager.setDefaultValues(getActivity(), R.xml.preferences, false);
			// Load the preferences from an XML resource
			addPreferencesFromResource(R.xml.preferences);
		}
	}
}
res/xml/preferences.xml
Nos sigue sirviendo el xml de la diapositiva anterior.
	

Ejercicio – recuperar las preferencias marcadas en la diapositiva anterior en dos textview en un nuevo Activity

	
SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);

//Dónde "primero" el atributo "key" del elemento <CheckBoxPreference> en el XML.
tv.setText(""+sp.getBoolean("primero", false));

	

SQLite

ejecutaremos una vez el siguiente código para que la base de datos aparezca en el file explorer (data → data → nombreDelPaquete → databases)

	
public void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);
	setContentView(R.layout.main);
        
	//La siguiente línea busca la base de datos. Si la encuentra la abre. si no, la crea
	SQLiteDatabase db = openOrCreateDatabase("nombre_base_datos", MODE_PRIVATE, null);
	db.close();
}
	

Para crear y manipular nuestra base de datos cómodamente

Plugin para firefox – sqlite manager:
https://addons.mozilla.org/en-us/firefox/addon/sqlite-manager/

Sqlite - read

	
public void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);
	setContentView(R.layout.main);
        
	//La siguiente línea busca la base de datos. Si la encuentra la abre. si no, la crea
	SQLiteDatabase db = openOrCreateDatabase("nombre_base_datos", MODE_PRIVATE, null);
	Cursor c = db.rawQuery("SELECT * FROM MyTable", null);
	c. moveToFirst();
	Log.d("LEE", c.getString(c.getColumnIndex("campo1")));
	c.close();
	db.close();
}
	

Después de hacer una consulta, si quiero leer los resultados de la misma debo llevar el cursor al punto a partir del cual quiero leer. De lo contrario no funcionará.

SQLite – precarga base de datos

		
public class MyApp extends Application {
	@Override
	public void onCreate() {
		super.onCreate();
		File file = this.getDatabasePath("nombre_base_datos");
		if (!file.exists()) {
			file.getParentFile().mkdirs();// Esto crea todas las carpetas para que la ruta a la bd exista. 
			Log.d("paso1", "copiamos la base de datos si no existía antes");
			OutputStream os = null;
			InputStream is = null;
			try {
				is = this.getResources().openRawResource(R.raw.nombre_base_datos);
				os = new FileOutputStream(file);
				byte[] buffer = new byte[1024];
				int length;
				while ((length = is.read(buffer)) > 0) {
					os.write(buffer, 0, length);
				}
				os.flush();
			} catch (Throwable t) {//e.printStackTrace();
			} finally {
				try {
					if (os != null)
						os.close();
				} catch (IOException e) {//e.printStackTrace();
				}
				if (is != null) {
					try {
						is.close();
					} catch (IOException e) {//e.printStackTrace();
}}}}}} //cierre de llaves..	
		
	

Para cargarlo desde el manifest debemos modificar el nodo application y añadir el atributo: android:name:

	
<application android:icon="@drawable/icon" android:label="@string/app_name" android:name=".MyApp" android:debuggable="false">		
	

Instalar la base de datos con cada actualización de la app

		
public class MyApp extends Application {
	@Override
	public void onCreate() {
		super.onCreate();
		private boolean hayActualizacion;
		SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
    		boolean flag = prefs.getBoolean("flag",false);
    		int version = prefs.getInt("version", -1);
		try {
			PackageInfo pInfo = getPackageManager().getPackageInfo(getPackageName(), 0);
			int posible_nueva_version = pInfo.versionCode;
			if(version<posible_nueva_version){
				hayActualizacion = true;
				SharedPreferences.Editor editor = prefs.edit();
				editor.putInt("version", posible_nueva_version);
				editor.commit();
			}else{
				hayActualizacion = false;
			}	
		} catch (NameNotFoundException e1) {e1.printStackTrace();}
    	//si la aplicación no se ha ejecutado nunca o hemos actualizado la app
    	if(!flag || hayActualizacion){
		SharedPreferences.Editor editor = prefs.edit();
		editor.putBoolean("flag", true);
		editor.commit();
		...	
		
	

	
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.pablomonteserin.almacenamiento.sqllite.ej"
android:versionCode="2" android:versionName="1.0">
	

Consultas SQL utilizando parámetros

	
//Creamos el registro a insertar como objeto ContentValues
ContentValues nuevoRegistro = new ContentValues();
nuevoRegistro.put("codigo", "6");
nuevoRegistro.put("nombre","usuariopru");
//Insertamos el registro en la base de datos
db.insert("Usuarios", null, nuevoRegistro);
----------------------------------------------------------------------------------------------

//Establecemos los campos-valores a actualizar
ContentValues valores = new ContentValues();
valores.put("nombre","usunuevo");
 
//Actualizamos el registro en la base de datos
db.update("Usuarios", valores, "codigo=6", null);
db.delete("Usuarios", "codigo=6", null);
	

OnChange de un spinner

		
Spinner sp = (Spinner) findViewById(R.id.spinner1);
		
sp.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
@Override
	public void onItemSelected(AdapterView<?> arg0, View arg1, int arg2, long arg3) {
		recalcular ();
	}
	@Override
	public void onNothingSelected(AdapterView<?> arg0) {
		// TODO Auto-generated method stub
	}
	// add some code here
});

		
	

Ejercicio

Para consultas de modificación:

	
db.execSQL("DELETE FROM invitado WHERE nombre=' pp'");


Para recorrer un cursor:
while(c.moveToNext()){
//No debemos hacer el c.moveToFirst(); en este caso
//o nos saltaremos el primer registro.

//Si quisiera comprobar si tras hacer la consulta encuentro valores:
mCursor.getCount() ==0



	

Para cargar un listView con los datos de una lista (objeto de tipo List):

	
listView.setAdapter(new ArrayAdapter(this,android.R.layout.simple_list_item_1,lista));
	

Alert dialog

	
AlertDialog.Builder builder = new AlertDialog.Builder(Main.this);
builder.setMessage("Are you sure you want to exit?");
//setCancelable determina si el cuadro de diálogo será cancelable utilizando la tecla de retroceso (BACK key)
builder.setCancelable(false);
builder.setPositiveButton("Yes", new DialogInterface.OnClickListener() {
	public void onClick(DialogInterface dialog, int which) {
		Main.this.finish();
	}
});
builder.setNegativeButton("No", new DialogInterface.OnClickListener() {
	public void onClick(DialogInterface dialog, int which) {
		dialog.cancel();
	}
});
AlertDialog alert = builder.create();
alert.show();
	

Simple Progress Dialog

final ProgressDialog pd = new ProgressDialog(this);
pd.setProgressStyle(ProgressDialog.STYLE_SPINNER);
pd.setMessage("Just wait...");
pd.setCancelable(true);

pd.show();

Progress dialog – horizontal style

		
final ProgressDialog pd = new ProgressDialog(this);
pd.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
pd.setMessage("Just wait...");
//setIndeterminate: en vez de una barra de progreso con un principio y un fin determinados, muestra una animación que no termina nunca
pd.setIndeterminate(false);
pd.setCancelable(true);
        
pd.show();
pd.setProgress(50);
		
	

Ejercicio - Personal dialog

Cuando haga click sobre un botón, deberá aparecer un cuadro de diálogo personalizado.

	

Dialog d = new Dialog(PersonalDialog.this);
d.setContentView(R.layout.personal_dialog);
d.setTitle("This is important");
d.show();
	

Creamos un layout llamado personal_dialog.xml para el dialog.

Toast - notificaciones instantáneas

Ejercicio: al pulsar el botón se muestra el mensaje mergente

		
Toast toast = Toast.makeText(Main.this, "El texto emergente",5000);
toast.setGravity(Gravity.CENTER, 0, 0);
toast.show();
		
	

Notification

		
NotificationCompat.Builder builder = new NotificationCompat.Builder(this)
.setSmallIcon(R.drawable.ic_launcher)
.setContentTitle("Titulo")
.setContentText("Mensaje");
		 
Intent notificationIntent = new Intent(this, SegundaActivity.class);
		 
PendingIntent contentIntent = PendingIntent.getActivity(this, 0, notificationIntent, PendingIntent.FLAG_UPDATE_CURRENT);
builder.setContentIntent(contentIntent);
builder.setAutoCancel(true);
builder.setLights(Color.GREEN, 500, 500);
builder.setSound(RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION));
	
NotificationManager manager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
manager.notify(1, builder.build());
		
	

Qué es una Lista

Una lista en el contexto de Activity es la interfaz gráfica que nos permite navegar por una serie de datos.

ID's de una lista

android:id="@android:id/list"
→ Utilizo una id ya existente en la API de android. Lo utilizo cuando extiendo de list activity.

android:id="@+id/miLista" →
Crea una nueva id

Extendiendo ListActivity

Para ello la activity debe heredar de la clase ListActivity y la lista debe ser identificada en el layout (main.xml) de la siguiente forma:

	
android:id=”@android:id/list”:
<ListView android:id="@android:id/list" android:layout_height="wrap_content" android:layout_width="match_parent">
</ListView>

public class Main extends ListActivity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
       setListAdapter(new ArrayAdapter<String>(this, 			
	android.R.layout.simple_list_item_1,
	getResources().getStringArray(R.array.countries)));
    }
}
res/values/countries.xml
<?xml version="1.0" encoding="UTF-8"?>
<resources>
	<string-array name="countries">
		<item name="usa">United States</item>
		<item name="brazil">Brazil</item>
		<item name="russia">Russia</item>
		<item name="egypt">Egypt</item>
		<item name="japan">Japan</item>
	</string-array>
</resources>
	

Mediante el método setListAdapter definimos cuál será el layout de cada uno de los items de la lista

El segundo parámetro carga un layout que traen las librerías de android

El tercer parámetro indica cuál es la información que cargará la lista.

El arrayAdapter está pensado para tener en cada posición una sola cosa, un texto, una foto, etc.

Content Provider

Nos permiten acceder a la información de otras aplicaciones incluida en un dispositivo, por ejemplo, a la agenda telefónica.

En un content provider los datos pueden estar almacenados:

• en una base de datos.
• en archivos.
• en una red.

Cómo acceder a los contactos

Para leer los contactos, primero habrá que añadir uno:
Símbolo del teléfono → botón de menú → Add contact.

Añadimos el permiso justo antes del cierre del Manifest:
<uses-permission android:name="android.permission.READ_CONTACTS" />

	
ContentResolver cr = getContentResolver();
Cursor contactos = cr.query(ContactsContract.Contacts.CONTENT_URI, null, null, null, null);
…
String name = contactos.getString(contactos.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME));
	

• FROM table_name
• WHERE col = value
• ORDER BY col,col,..
• El array de columnas que será incluído en cada fila recuperada
• Remplazo de las ? En la clausula anetrior

Obtener los teléfonos

		
ContentResolver cr = getContentResolver();
Cursor contactos = cr.query(ContactsContract.Contacts.CONTENT_URI, null, null, null, null);
String phoneNo = "";
if (contactos.getCount() > 0) {
	while (contactos.moveToNext()) {
		String id = contactos.getString(contactos.getColumnIndex(ContactsContract.Contacts._ID));
		String name = contactos.getString(contactos.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME));
		if (Integer.parseInt(contactos.getString(contactos.getColumnIndex(ContactsContract.Contacts.HAS_PHONE_NUMBER))) > 0) {
			Cursor pCur = cr.query(ContactsContract.CommonDataKinds.Phone.CONTENT_URI,null,
				ContactsContract.CommonDataKinds.Phone.CONTACT_ID+ " = ?", new String[] { id }, null);
			while (pCur.moveToNext()) {
				phoneNo = pCur.getString(pCur.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER));
				String user = "Name: " + name + ", Phone No: "+ phoneNo;
				Log.d("user", user);
			}
			pCur.close();
		}
	}
}
		
	

Ejercicio

Recuperar los contactos del teléfono y mostrarlos en un ListView

Lista sin extender de ListActivity

		
public class Main extends Activity {
	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
		ListView lv = (ListView) findViewById(R.id.miLista);
		lv.setAdapter(new ArrayAdapter<String>(this, 			
				android.R.layout.simple_list_item_1,
				getResources().getStringArray(R.array.countries)));
	}
		
	

Mediante el método setAdapter definimos cuál será el layout de cada uno de los items de la lista

El segundo parámetro carga el layout personalizado que he hecho.

El tercer parámetro indica cuál es la información que cargará la lista.

Adapter

Escogeremos el tipo de Adapter a usar en función de los datos que queremos cargar.

• Si tenemos un ArrayList de Strings usaremos ArrayAdapter.
• Si tenemos un cursor de la base de datos, usaremos CursorAdapter.
• BaseAdapter puede usarse para cualquier cosa, es muy versátil, aunque requiere algo mas de código.

Haciendo que cada row cargue un layout personalizado
para ello hay que sobrescribir el método getView del Adapter

1. Creamos un nuevo layout que utilizarán cada para cada uno de los elementos de la lista, llamado list_item_layout.xml.
2. Añado un textview y un imageview al layout.
3. Me aseguro de que el layout sea horizontal y no vertical (vamos a ir poniendo filas, no columnas).
4. En la siguiente diapositiva, el código de la clase Main.java.

Utilizando BaseAdapter

		
ListView lv = (ListView) findViewById(R.id.miLista);
lv.setAdapter(new MyAdapter(getPaises()));
...
public ArrayList<Pais> getPaises() {
	ArrayList<Pais> paises = new ArrayList<Pais>();
	paises.add(new Pais("United States", "flag_usa"));
	paises.add(new Pais("Brazil", "flag_brasil"));
	paises.add(new Pais("Russia", "flag_russia"));
	paises.add(new Pais("Egypt", "flag_egypt"));
	paises.add(new Pais("Japan", "flag_japan"));
	return paises;
}
...
private class MyAdapter extends BaseAdapter {
	ArrayList<Pais> paises;
	public MyAdapter(ArrayList <Pais>paises) {
		super();
		this.paises = paises;
	}
	@Override
	public int getCount() {
		return paises.size();
	}
//MyAdapter llama automáticamente al método getView para cargar la lista con información
//Dicho método se va llamar muchas veces (una cada vez que tenga que pintar una posición de la lista)
	public View getView(int position, View convertView, ViewGroup parent) {
		View row = View.inflate(MainActivity.this,R.layout.list_item, null);
		TextView tv = (TextView) row.findViewById(R.id.textView1);
		ImageView iv = (ImageView) row.findViewById(R.id.imageView1);
		tv.setText(paises.get(position).getNombre());
		//getPackageName() me devuelve el nombre del paquete que identifica a nuestra aplicación
		iv.setImageResource(getResources().getIdentifier(paises.get(position).getImg(), "drawable", getPackageName()));
		return row;
	}
		
	

Optimizaciones

Optimización fundamental del adapter

		
@Override
public View getView(int position, View convertView, ViewGroup parent) {
	View row;
	//convertView almacena temporalmente cada una de las filas de la lista. Cuando la fila deja de ser visible tendré un convertView con la fila ya inflada no estoy utilizando. Puedo reutilizarlo para almacenar la siguiente fila, en vez de crear uno nuevo
	if(convertView == null)row = View.inflate(ItemListConImgActivity.this, R.layout.list_item, null);
	else row = convertView;

//Antes de optimización, para una lista de 100 filas tendría que inflar las 100, utilizando apropiadamente el convertView, me basta con inflar sólo las que se están viendo en pantalla
		
	

Optimización útil para listas grandes

		
private class MyAdapter extends ArrayAdapter<String>{
…
	public View getView(int position, View convertView, ViewGroup parent) {
		View row;
		//Con esta optimización conseguimos llamar sólo 10 veces al findViewById, en vez de 100. 			
		//Ideal para listas largas.
		if(convertView == null){
			row = View.inflate(ItemListConImgActivity.this, R.layout.list_item, null);
			ViewHolder vh = new ViewHolder();
			vh.iv = (ImageView) row.findViewById(R.id.imageView1);
			vh.tv = (TextView) row.findViewById(R.id.textView1);
			row.setTag(vh);
		}else row = convertView;
		ViewHolder vh = (ViewHolder) row.getTag();
		vh.tv.setText(items[position]);
		vh.iv.setImageResource(getResources().getIdentifier(itemsImg[position], "drawable", getPackageName()));
		return row;
	}
…
	private static class ViewHolder{
		TextView tv;
		ImageView iv;
	}
}
		
	

Ejercicio - plantas

Crearemos una lista de plantas: static List<Planta> plantas; y haremos que el Activity implemente la interfaz OnItemClickListener, de tal forma que al hacer click sobre un Item iremos a otro activity pasándole los datos de la planta seleccionada.

		
startActivity(new Intent(this,InfoActivity.class).putExtra(PLANTA,plantas.get(position)));
		
	

Ejercicio - plantas II

Para hacer la siguiente ampliación del ejercicio, deberemos utilizar una base de datos.

Añadir un ToggleButton al segundo activity. Al pulsarlo, la planta correspondiente en el activity principal se mostrará pintada de verde. Para ello cambiaremos un campo llamado “is_checked” definido en la base de datos.

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

	
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

	

implementando LocationListener)

	
public class TrackingActivity extends Activity implements LocationListener {
public void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);
	setContentView(R.layout.main);
	LocationManager lm = (LocationManager)this.getSystemService(Context.LOCATION_SERVICE);
	lm.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0,this);
	//El NETWORK_PROVIDER sólo funciona en el teléfono móvil, no en el emulador
	//lm.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 0, 0,this);
}

public void onLocationChanged(Location arg0) {
	Toast toast = Toast.makeText(this, "Latitud: "+ arg0.getLatitude()+" Longitude: "+ arg0.getLongitude(), Toast.LENGTH_LONG);
	toast.show();
}
//Esto ocurre cuando desactivas el gps, la red móvil, etc
public void onProviderDisabled(String arg0) {}

//Esto ocurre cuando activas el gps, la red móvil, etc.
public void onProviderEnabled(String arg0) {}
	

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

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.

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);
		
	

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.

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

1. Vista project → app → build.gradle → en dependencias añado lo siguiente: compile 'com.google.android.gms:play-services:+'
2. 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-sdk android:minSdkVersion="8" android:targetSdkVersion="19" />
    <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 android.support.v4.app.FragmentActivity {
private GoogleMap mapa;

	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.acitivity_main);
			
		

Centrar el mapa en un punto

		
public class MainActivity extends android.support.v4.app.FragmentActivity {
private GoogleMap mapa;
…
 mapa = ((SupportMapFragment) getSupportFragmentManager()
                .findFragmentById(R.id.map)).getMap();
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 camUpd3 = CameraUpdateFactory.newCameraPosition(camPos);
        
mapa.animateCamera(camUpd3);
		
	

Geolocalización con mapas

	
…
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);
    }
	

Pintar puntos

		
mapa.addMarker(new MarkerOptions().position(myLatLng).icon(BitmapDescriptorFactory.fromResource(R.drawable.icon)));
		
	

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.

	
Notas:
Marker marker = mapa.addMarker(new MarkerOptions()
	.position(new LatLng(lat, lon))
	.snippet(monumento.getDescripcion())
	.title(monumento.getNombre())
	.icon(BitmapDescriptorFactory.fromResource(R.drawable.escudo)));			
tabla.put(marker, monumento.getId());

monumentos es un HashMap de objetos Monumento.

Para pasar los datos del enclave pulsado de un Activity a otro:
startActivity(new Intent(GeolocalizacionCapasActivity.this,
LugarActivity.class).putExtra(MONUMENTO, monumentos.get(arg0)));

Para recibirlo:
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

Rutas I

		
LatLng Barcelona = new LatLng(41.387917,2.169918);
String url = makeURL(Madrid.latitude, Madrid.longitude, Barcelona.latitude, Barcelona.longitude);
new connectAsyncTask().execute(url);
		
	

AsynTask

Si no usamos el task y la conexión tarda más de 5 segundos, Android nos saca un cuadro de dialogo donde nos pregunta se queremos forzar el cierre de la aplicación

	
new MiAsyncTask().execute("http://pablomonteserin.com/apuntes/java/rec/login.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> {
	protected String doInBackground(String... urls) {
//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
		return txt;
	}
	protected void onPostExecute(String txt) {
//El método onPostExecute debe recibir lo que devuelve el doInBackground (en este caso, un String)
	}
}
	

Rutas II

	
private class connectAsyncTask extends AsyncTask<String, Void, String> {
	private ProgressDialog progressDialog;

	@Override
	protected void onPreExecute() {
		super.onPreExecute();
		progressDialog = new ProgressDialog(MainActivity.this);
		progressDialog.setMessage("Calculando ruta, por favor espere...");
		progressDialog.setIndeterminate(true);
		progressDialog.setCancelable(false);
		progressDialog.show();
	}
	@Override
	protected String doInBackground(String... urls) {
		JSONParser jParser = new JSONParser();
		String json = jParser.getJSONFromUrl(urls[0]);
		return json;
	}
	@Override
	protected void onPostExecute(String result) {
		super.onPostExecute(result);
		progressDialog.hide();
		if (result != null) {
			drawPath(result);}}}
	

Rutas III

		
private void drawPath(String result) {
		try {
			// Tranform the string into a json object
			final JSONObject json = new JSONObject(result);
			JSONArray routeArray = json.getJSONArray("routes");
			JSONObject routes = routeArray.getJSONObject(0);
			JSONObject overviewPolylines = routes.getJSONObject("overview_polyline");
			String encodedString = overviewPolylines.getString("points");
			List<LatLng> list = decodePoly(encodedString);
			for (int z = 0; z < list.size() - 1; z++) {
				LatLng src = list.get(z);
				LatLng dest = list.get(z + 1);
				Polyline line = mapa.addPolyline(new PolylineOptions()
						.add(new LatLng(src.latitude, src.longitude),
								new LatLng(dest.latitude, dest.longitude))
						.width(2).color(Color.BLUE).geodesic(true).width(6f));
				listaPolylineas.add(line);
			}
		} catch (JSONException e) {}
	}
		
	

Rutas IV

	
private List<LatLng> decodePoly(String encoded) {
	List<LatLng> poly = new ArrayList<LatLng>();
	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;
}
	

Servicios

Nos permiten acceder a funcionalidades del teléfono (webcam, cámara de fotos, wifi, etc.)

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 = (TextView) 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 = (TextView) 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){
					
				}
			}
        	
        });
    }
}
		
	

XML

Abrir fichero XML

	
InputStream  inputStream = 

this.getResources().getAssets().open("libros.xml");
	

Traza de inicio, fin e intermedios de Nodo

		
//El siguiente import es necesario
import org.xml.sax.Attributes;
//No confundir con el import java.util.jar.Attributes;

public class XML_parser extends DefaultHandler {
	public void parsear(InputStream inputStream)
	throws ParserConfigurationException, SAXException, IOException {
		final SAXParser parser = SAXParserFactory.newInstance().newSAXParser();
		final ParserAdapter adapter = new ParserAdapter(parser.getParser());
		adapter.setContentHandler(this);
		adapter.parse(new InputSource(inputStream)); 
	}
	public void startElement(final String uri, final String localName,
	final String name, final Attributes attributes) throws SAXException {
		Log.d("startElement", "Name: " + name);
	}
	public void characters(final char[] chars, final int start, final int length)
	throws SAXException {
		String caracteresUtiles = String.copyValueOf(chars, start, length);
		Log.d("Caracteres utiles", caracteresUtiles);
	}
	public void endElement(final String uri, final String localName,
			final String name) throws SAXException {
		Log.d("endElement", "Name: " + name);
	}
}
		
	

		
<?xml version="1.0" encoding="utf-8"?>
<libros>
    <libro>Viaje la luna</libro>
    <libro>Buscando a Wally</libro>
</libros>
		
	

Ejercicio - parsear XML

Dependiendo del valor de name, crear objetos de la clase libro, setear su propiedad título e introducirlos en una lista.

Hacer que el parser devuelva dicha lista.

Consejo:
Para darle un título al libro usaremos libro.setTitulo(titulo) dentro del método endElement, en lugar de dentro del método characters. Si seteasemos el título dentro del método characters, después de haber leído el texto de un nodo leeríamos el espacio vacío y el salto de línea que hay después del nodo y machacaríamos el valor anterior.

	
<?xml version="1.0" encoding="utf-8"?>
<libros>
    <libro>Viaje la luna</libro>----------------------------------------------------------------------
----<libro>Buscando a Wally</libro>
</libros>
	

Aunque para almacenar el título nos resultará cómodo usar un String, tener en cuenta que esto no es aconsejable ya que no debemos instanciar String dentro de un bucle a casa de los problemas de rendimiento que esto implica. En su lugar, deberíamos usar StringBuffer o StringBuilder.

Ejercicio

El xml ahora tendrá la siguiente forma:

	
<?xml version="1.0" encoding="utf-8"?>
<libros>
	<libro>
		<titulo>Viaje a la luna</titulo>
		<autor>Julio Verne</autor>
	</libro>
	<libro>
		<titulo>Buscando a Wally</titulo>
		<autor>Martin Handford</autor>
	</libro>
</libros>		
	

Dependiendo del valor de name, crear objetos de la clase libro, setear sus propiedades e introducirlos en una lista.

Hacer que el parser devuelva dicha lista.

Leer un fichero muy grande poco a poco

	
final byte[] buffer = new byte[1024];
ByteArrayOutputStream byteArrayOutPutStream = new ByteArrayOutputStream(1024);
int length;
//inputStream.read(buffer) -> lee de inputStream y los va metiendo en buffer
//si lo que lee es -1 es que ya no hay nada más que leer
while ((length = inputStream.read(buffer)) != -1) {
	//colocar el contenido de buffer en byteArrayOutPutStream
	byteArrayOutPutStream.write(buffer, 0, length);
}
Log.d("byteArrayOutPutStream", ""+byteArrayOutPutStream.toString());
String txt = byteArrayOutPutStream.toString( "utf-8" );
	

JSON

	
public ArrayList<Libro> parsear(String txt)
	throws ParserConfigurationException, SAXException, IOException {
	libros = new ArrayList<Libro>();
//...diapositiva anterior
/* JSONObject es la librería que viene en Android por defecto para parsear la información. Esta debe estar totalmente descargada en el equipo para que pueda ser parseada (no soporta streaming).
	JSONObject jsonObject = new JSONObject(txt);
	JSONArray arrayLibros = jsonObject.getJSONArray("libros");
	for(int i=0; i<arrayLibros.length(); i++){
		Libro libro = new Libro();		
		libro.setTitulo(arrayLibros.getJSONObject(i).getString("titulo"));
		libro.setAutor(arrayLibros.getJSONObject(i).getString("autor"));
		libros.add(libro);
	}

	return libros;
}
	

libros.json. Un corchete cuadrado es un array y una llave es un objeto
{
    "libros": [
    {
        "titulo": "Viaje a la Luna",
        "autor": "Julio Verne"
    },
    {
        "titulo": "Buscando a Wally",
        "autor": "Martin Handford"
    }
    ]
  }			
	

Coger una imagen desde una url

Es algo muy cómodo si usamos la librería Picasso. Dejaremos el jar en la ruta assets/libs/Picasso.jar → Botón derecho sobre la librería → Add as library

		
Picasso.with(context).load(url).into(imageView);
		
	

Envío/Recepción de información

		
/********************************** ENVIO INFORMACION*/
	DefaultHttpClient httpClient = new DefaultHttpClient();
	HttpPost postRequest = new HttpPost(urls[0]);
	HttpResponse response = httpClient.execute(postRequest);
/********************************** FIN ENVIO INFORMACION */
/********************************** PROCESAMIENTO RESPUESTA */
	int http_status = response.getStatusLine().getStatusCode();
	if (http_status == 200) {
	HttpEntity entity = response.getEntity();

	if (entity != null) {
		respuesta = EntityUtils.toString(entity, HTTP.UTF_8);
	... 
	httpClient.getConnectionManager().shutdown();  
		
	

Ejercicio searchUPC

El código UPC que escribimos se lo mandaremos a la cuenta
https://pablomonteserin.com/apuntes/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" />

Mientras que se está realizando el envió y la recepción de la información solicitada, veremos en pantalla una progressBar.

El layout del listview será un linear layout. Para bloquear el listener del imageview y del textview que tiene dentro y escuchar sólo cuando hago click sobre una fila del listview, añadiré el atributo android:descendantFocusability="blocksDescendants" al linearlayout.

Al pulsar sobre la foto, vamos al siguiente Activity. En el segundo activity mostraremos el resto de los datos y si pulsamos sobre el botón de ir a página web iremos a la web indicada en el bea.

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
		
	

Adjuntar la base de datos

Por defecto la base de datos de mi aplicación no está adjuntada al programa, para que la base de datos se despliegue correctamente habrá que:

Crear una carpeta raw dentro de la carpeta res y pegar ahí el fichero de la base de datos.

Para ello debemos crear un .java que copiará la base de datos de nuestra carpeta raw a la carpeta donde se alojas las bases de datos en el móvil.

		
public class MyApp extends Application {
	@Override
	public void onCreate() {
		super.onCreate();
		
		File file = this.getDatabasePath("j2ee_questions");
		if(!file.exists()){
			file.getParentFile().mkdirs();//Esto crea todas las carpetas para que esta ruta exista. Esta es la ruta de la base de datos.
			Log.d("paso1", "copiamos la base de datos si no existía antes");

			OutputStream os = null;
			InputStream is = null;
			try {
			is = this.getResources().openRawResource(R.raw.j2ee_questions);
			os = new FileOutputStream(file);
			byte []buffer = new byte[1024];
			int length ;
			 while ((length = is.read(buffer)) > 0) {
	                	os.write(buffer, 0, length);
	       	}
	       	os.flush();
		}catch(Throwable t){
			Log.d("paso1", "error3"+t.toString());
		}finally{
			try {
				if(os!= null)os.close();	   

			} catch (IOException e) {
					//e.printStackTrace();
			}
			if(is!=null){
				try {
					is.close();
				} catch (IOException e) {
				//	e.printStackTrace();
				}

			}
		}
		}	
	}
}
		
	

En el AndroidManifest.xml habrá que añadir este atributo en el nodo Aplication:

		
android:name="com.pablomonteserin.MyApp