1 - Instalacin de las herramientas

necesarias para programar para Android

Studio
Descargar e instalar JDK(Java development kit) y Android Studio(instalando tambien el
Android SDK)

2 - Pasos para crear el primer proyecto

Android Studio
Le damos a Start a new android studio project:
Application name: el nombre que tendra la aplicacion
Company Domain: para el nombre de los paquetes
Seleccionar los dispositivos y la minima version requerida.
Despues la opcion de Blak Activity para que sea como una aplicacion normal (no a pantalla
completa)
En la ltima ventana no cambiar nada.
Esto generara todos los archivos necesarios.
En la ruta res>layout se encuentra un archivo llamado activity_main.xml que contiene toda la
informacion de la interfaz visual de la primera pantalla de nuestro programa. Si lo seleccionamos, lo
podemos editar de manera Design o Text(cdigo).
Ejemplo y ejecucion de una aplicacion:
En la vista de Design. Borramos el label e insertamos un Button que en properties>text y le
ponemos cualquier nombre.
Luego al boton verde o run>run app y nos saldra el emulador con la aplicacion.
Si queremos hacer cambios en la aplicacion, no cerrar el emulador, siemplemente darle otra vez al
boton para ejecutarla.

3 - Capturar el clic de un botn

Objetivo: crear un programa al que le pases dos numeros y al darle al boton te devuelva la suma.
Aadimos un Medium Text y le cambiamos el nombre a Ingrese el primer valor y la id a tv1. La
id se usar para referirnos a este objecto, en este caso es un objeto de la clase TextView.
Hacemos lo mismo con un Number de Text Fields que es de la calse EditText y su id sera et1.
Hacemos lo mismo otra vez para obtener los dos cuadros.
Despues creamos un botn con el texto Suma y la id button.
Volvemos a aadir otro Medium Text sin texto para que muestre el valor.
Con esto tendremos ya todo lo necesario sobre la interfaz del programa. Ahora hara falta programar
el comportamiento del programa.
Para ello, abrimos el MainActivity.java. En ella veremos como la clase MainActivity es heredada de
la clase ActionBarActivity que tiene todos los metodos necesarios para crear y mostrar los objetos
del xml.
Este archivo viene asi por defecto. En el, tendremos que sobrescribir el metodo onCreate donde
llamaremos al metodo setConentView pasandole como referencia un objecto de la clase layout

mediante la clase R(clase creada por Android Studio para conectar el xml con el MainActivity).
Unicamente crearemos objectos de los objetos con los que vayamos a interactuar, en este caso con
los dos primeros EditText y con el ultimo TextView (el click del boton se hace directamente desde
el xml), para ello (no tienen por qu llamarse igual):
private EditText et1,et2;
private TextView tv3;
eso ira en clase, fuera de los metodos. Dentro del metodo onCreate tendremos que defenir esas
referencias mediante:
et1=(EditText)findViewById(R.id.et1);
et2=(EditText)findViewById(R.id.et2);
tv3=(TextView)findViewById(R.id.tv3);
el mtodo findViewById(objecto de la clase R) devuelve un objecto View y es por ello que hay que
hacerle el cast.
Por ltimo habra que crear el mtodo void a ejecutar cuando se pulse al boton, para ello creamos un
nuevo mtodo en la clase con parmetro un objeto de la clase View. Asignamos en el xml el mtodo
que tiene que ejecutar cuando se le cliquee en onClick. El mtodo sera algo asi:
public void sumar(View view){
String valor1=et1.getText().toString();
String valor2=et2.getText().toString();
int nro1=Integer.parseInt(valor1);
int nro2=Integer.parseInt(valor2);
int suma=nro1+nro2;
String resu=String.valueOf(suma);
tv3.setText(resu);
}

4 - Controles RadioGroup y RadioButton

Objetivo: Aadir al programa anterior la posibilidad de elegir entre sumar o restar que se realizara
cuando se presione el boton.
Para ello insertaremos un RadioGroup y dentro de l los RadioButton con cada una de las opciones.
TIP: si el layout:heigth y el width le ponemos wrap_content, el cuadro solo ocupara lo que ocupen
sus botones.
Le pondremos una id a cada RadioButton y los crearemos con el findViewById.
Para saber si el boton esta seleccionado, usaremos el metodo id.isChecked() que sera true si si que
lo esta.

5 - Control CheckBox
Objetivo: Lo mismo que el anterior pero con CheckBox(cajitas con ticks) siendo posible
seleccionar ambas opciones.

Poner dos CheckBox para sumar/restar. Se aaden con findViewById y para saber si estan
seleccionados usaremos el metodo id.isChecked() que sera true si si que lo esta.

6 - Control Spinner
Objetivo: Lo mismo que el anterior pero con un Spinner que es una lista despegable.
Para ello, aadiremos el Spinner y lo aadiremos como siempre con el findViewById.
Luego creamos un array con lo que queremos que muestre (todo esto en el onCreate):
String []opciones={"sumar","restar","multiplicar","dividir"};
ArrayAdapter<String> adapter = new ArrayAdapter<String>(this
,android.R.layout.simple_spinner_item, opciones);

spinner1.setAdapter(adapter);
Se le pasa al ArrayAdapter un Activity (this), una configuracion y
el string con las opciones
la configuracion puede ser :

simple_spinner_item (toda la anchura de la pantalla)

simple_spinner_dropdown_item (anchura de la palabra mas

larga)

Para saber que opcion del menu esta marcada utilizaremos el metodo
spinner.getSelectedItem().toString()
y
luego
normalente
un
.equals() para que haga una cosa u otra

7 - Control ListView
Objetivo: Aperecen todos los nombres de unos paises(posibilidad de scroll), al seleccionar uno,
muestra el n de habitantes
El ListView es como un Spinner pero fijo y scrollable.
Insertamos un ListView y un TextView para que lo muestre. Creamos sus objectos con el metodo
findViewById.
Creamos dos arrays, uno con los paises y otro con los habitantes. Y asignamos al ListView los
paises similar a como se ha hecho antes
ArrayAdapter<String> adapter = new ArrayAdapter<String>(this
,android.R.layout.simple_spinner_item, paises);

spinner1.setAdapter(adapter);

Para indicar que tiene que hacer al ser cliqueado cada uno de sus elementos, haremos (en onCreate):
lv1.setOnItemClickListener(new AdapterView.OnItemClickListener() {
@Override
public void onItemClick(AdapterView parent, View view, int position, long id) {
tv1.setText("Poblacin de "+ lv1.getItemAtPosition(position) + " es "+
habitantes[position]);
}
});

Habra que reinscribir el metodo setOnItemClickListener y dentro de l el onItemClick diciendo que

hace cuando es seleccionado.
Nota: este metodo va dentro del metodo onCreate para que te lo sobrescriba nada mas se inicia la
aplicacin, este metodo se ejecutara nada mas se pulse un elemento de la lista

8 - Control ImageButton
Objetivo: Crear un boton con una imagen que al ser pulsado muestre un texto en un TextView
La imagen debera de ser copiada a app/src/main/res/drawable-mdpi.
Aadir el ImageButton y en sus propiedades, asignar la imagen al parametro src
Recordemos que para decir que hara el boton al ser pulsado, creamos un metodo y se lo asignamos
al paremetro onClick
Nota: Para evitar que la imagen tenga la misma calidad sea cual sea el dispotivo, habria que guardar
las imagenes con el mismo nombre y diferentes tamaos en las demas carpetas:

En la carpeta res/drawable-mdpi/ (guardamos la imagen con el tamao original)

En la carpeta res/drawable-ldpi/ (guardamos la imagen con el tamao del 75% con respecto
al de la carpeta drawable-mdpi)

En la carpeta res/drawable-hdpi/ (guardamos la imagen con el tamao del 150% con

respecto al de la carpeta drawable-mdpi)

En la carpeta res/drawable-xhdpi/ (guardamos la imagen con el tamao del 200% con

respecto al de la carpeta drawable-mdpi)

En la carpeta res/drawable-xxhdpi/ (guardamos la imagen con el tamao del 300% con

respecto al de la carpeta drawable-mdpi)

9 Notificaciones sencillas mediante la

clase Toast
Objetivo: Generar un numero aleatorio que se notifica mediante una ventana emergente, luego el
usuario debera de ingresarlo. Mediante otra ventana emergente, decir si es o no el mismo numero

Crearemos un textView para indicar que hay que ingresar el numero, un textEdit para aadirlo y un
button para compararlos.
En el codigo, creamos el editText y un integer con un valor aleatorio. Lo convertimos a texto ya que
el Toast solo muestra String.
Creamos un objecto de la clase Toast mediante su clase esttica makeText y los paremetros de la
activity, el string y una constante para el tiempo que lo muestrara:
Toast notificacion=Toast.makeText(this,cadena,Toast.LENGTH_LONG);
y cuando queremos mostrar el texto, utilizaremos el metodo show.
Por ultimo faltaria crear el metodo que es ejecutado al pulsar el boton que te mostrara un mensaje
distinto, dependiendo de si el numero introducio es igual o no.
Nota: no es Toast notificacion = new
Toast.makeText(this,cadena,Toast.LENGTH_LONG); porque de la otra manera no
creamos un nuevo objeto cada vez, llamamos al metodo estatico que nos devuelve el objeto ya
creado, es decir, no creamos distintas copias del objecto que crea los mensajes

10 Control EditText
Dentro de los EditText podemos ver que hay muchos tipos de ellos, usaremos uno u otro en funcion
de lo que queremos que el usuario entre
Objetivo: Pedir al usuario un nombre y una contrasea, verificar, al pulsar un boton, si se ingreso
algo en el campo contrasea, en caso de que no notificarlo mediante un Toast
Poner dos campos, uno de Person Name y otro de Password. Aadir los dos campos al codigo y
crear el metodo que se usara al pulsar el boton.
Obtendremos el texto con .getText().toString(), luego comprabar si esta vacio con .length()==0 y en
caso de que si, mostrar un Toast.

11 Lanzar un segundo Activity

Un Activity es cada uno de las distintas ventanas de una app, estan formadas por un XML(interfaz
grafica) y el cdigo de Java(comportamiento de esa ventana)
Objetivo: Crear una app donde haya un botn que al pulsarlo pase a otro Activity. En esa nueva
Activity habr un texto y un botn para cerrar esa Activity y volver a la principal.
Aadimos un botn. Luego creamos un nuevo Activity en New>Activity>Blank Activity, le
asignamos un nombre. El archivo java se llamara, nombre.java y el XML ser activity_nombre.xml.
En la nueva Activity ponemos un textView y un botn.
Para cambiar de Activity, crearemos un metodo en la Activity main que sera ejecutado al pulsar el
botn, dicho metodo ser:

public void boton(View view){

Intent i = new Intent(this,nombre.class);
startActivity(i);
}

Por otra parte, tenemos el boton de la segunda Activity que debe de volver a la main, en este caso
(al querer cerrar esta Activity) el metodo del boton sera:
public void boton(View view){
finish();
}

12 Lanzar un segundo Activity y pasar

parmetros (y utilizacin de WebView)
Objetivo: En la primera Activity pedir que ingrese una direccion en la web, ese String lo debe de
pasar a la segunda Activity donde se mostrara este sitio Web
Aadir a la primera Activity un campo de texto(para la direccion web) y un boton. El metodo de
este boton sera:
public void boton(View view){
Intent i = new Intent(this,nombre.class);
i.putExtra(direccion, et1.getText().toString());
startActivity(i);
}

Para el metodo putExtra, el primer parametro es el nombre del dato y el segundo el dato en s.
Luego creamos la nueva Activity y aadimos un WebView, en el metodo onCreate crearemos este
objeto y aadiremos:
Bundle bundle = getIntent().getExtras();
String dato = bundle.getString(direccion);
webView1.loadUrl(http:// + dato);

El bundle sirve para recuperar los parmetros enviados desde donde se lanzo esta Activity y lo otro
es para abrir el navegador.
Nota: esta app requiere acceso a internet, para ello le hacen falta permisos, estos se aaden al
AndroidManifest.xml, lo abrimos y aadimos:
<uses-permission android:name="android.permission.INTERNET" />

17 Instalacin del programa Android en

un dispositivo real
Cada vez que ejecutamos la app en un disposotivo virtual se crea
un instalador apk en app/build/outputs/apk

Los layouts se usan para organizar los

distintos elementos de cada Activity.
La RelativeLayout es la que viene por
defecto.

18 Layout (LinearLayout)
El LinearLayout sirve para establecer los componentes uno junto a otro de manera horizontal o
vertical
Aadimos un LinearLayout y dentro de l diversos elementos. En sus propiedades podemos
cambiar el valor de la orientation que podran ser Horizontal o Vertical. Tambien nos puede interesar
cambiar el layout:height a wrap_content para que la altura de ese Layout sea solo la de sus
componentes y podamos aadir otros (Nota: todos los elementos que se salen de la pantalla sera
inaccesibles).
La RelativeLayout aade los componentes de manera libre y modificable, pero si queremos que se
comporte de alguna manera en especial podemos indicarselo. Para ello vamos al archivo XML en
modo Text, en ella cambiamos donde pone RelativeLayout, tanto al principio como al final, por
LinearLayout y aadiriamos la propiedad de la orientacion, android:orientation=vertical

19 Layout (TableLayout)
El TableLayout te organiza los elementos en filas y columnas (cada fila puede tener un numero
variable de componentes).
Aadimos el TableLayout y al aadir un elemento, el programa creara solo el TableRow que es el
subgrupo de elementos de esa fila.
El TableLayout te lo organiza por celdas, si queremos tres filas con tres botones de manera 3x3 y
abajo un boton que ocupe todo. Cada boton ocupara una celda excepto el ultimo que ocupara tres
celdas, esto se indica en las propiedades de ese elemento layout:span.

20 Layout (FrameLayout) (Y visibilidad)

Permite apilar los componentes en el borde izquierdo, centro-arriba, borde derecho, centroizquierda, centro... (9 opciones). Los componentes apareceran superpuestos. Es util cuando
queremos que al pulsar en un boton ese se vuelva invisible y aparezca otra cosa.
Para hacer invisible un componente, se puede hacer desde el XML en modo diseo cambiando la
propiedad de visibility que puede ser visible o invisible.
Si queremos que esto se modifique desde el codigo java, basta con
id.setVisibility(View.INVISIBLE o View.VISIBLE)

21 Layout (ScrollView y LinearLayout)

Permite que se contengan ms componentes de los que caben en la pantalla.
Para ello aadiremos un ScrollView y modificamos las propiedades de layout:width y layout:height
a match_parent con esto conseguiremos que ocupe toda la pantalla.
Luego aadimos a l un LinearLayout vertical y aadiremos los componentes por orden al
Component Tree.

22 Icono de la aplicacin
Como ya hemos dicho, las imagenes se guardan en \app\src\main\res\drawable-mdpi, y tambien esta
ldpi, mdpi, hdpi y xhdpi. Esto es debido a las distintas posibles resoluciones de los dispositivos, la
regla oara almacernalo es:

drawable-mdpi el icono sera de 48x48

drawable-hdpi el icono sera de 72x72

drawable-xhdpi el icono sera de 96x96

drawable-xxhdpi el icono sera de 144x144

Para cambiar el icono, aadiremos el nuevo icono con distintas resoluciones pero con el mismo
nombre en las distintas carpetas, borraremos el icono que viene de fabrica y por ultimo, le
indicaremos el nuevo icono en el AndroidManifest.xml en android:icon=@drawable/name SIN
EXTENSION.

41 Archivo strings.xml
El archivo strings.xml sirve para tener todas las cadenas de texto de nuestro programa en un unico
archivo, siendo asi mucho mas sencillo cambiar cada valor.
Este archivo se crea por defecto en /app/res/values/strings.xml
Para guardar cada uno de los strings, usamos esta codificacin:
<string name=hello_world>Hello world!</string>

Donde, el nombre de la variable es hello_world y su contenido es Hello world!

Para poder usar esta variable, nos referiremos a ella con @string/hello_world. Tambien la podemos
encontrar dandole a los tres puntos que estan al lado del text, alli seleccionaremos la variable que
queramos de la pestaa Project.
Si queremos acceder al String desde el codigo usaremos getString(R.string.hello_world)
Para crear cada una de estas constantes, lo podemos hacer:

directamente aadiendolas a mano

Presionando en open editor en el strings.xml, donde le indicaremos la key (la referencia) y

el default value (su contenido)

Desde la vista diseo, al lado de text habran tres puntos (sirven para seleccionar las
constantes), le damos a new resource y le asignamos el resource name (la referencia), el
resource value (su contenido) y el file name (que sera strings.xml)

42 Internacionalizacin y archivo
strings.xml
Se consigue implementado diversos archivos strings.xml, uno para cada idioma.
Para crear diversos archivos xml, le daremos click derecho en values y new>values resource files,
en esa ventana seleccionaremos que lo queremos diferenciar por el idioma y elegimos el que
queramos.
En el nuevo archivo debemos de aadir todas las variables que existen en el strings.xml que viene
por defecto pero traduciendo su contenido.
El archivo strings.xml sera el que se use por defecto, mientras que cada uno de los diversos archivos
sera los que usara en caso de que se satisfaga la condicion puesta.

43 Localizacin y archivo strings.xml

Al igual que antes, al crear el nuevo strings.xml, podemos distingirlos por regiones en vez de por
idiomas.

44 Componente ActionBar (Bsica)

El archivo strings.xml sirve para tener todas las cadenas de texto de nuestro programa en un unico
archivo.

EXTRA
AlertDialog simple
Una ventana con un titulo, un mensaje y un boton para cerrarlo. El codigo sera:
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setTitle("Importante");
builder.setMessage("Este es un programa solo de prueba
completa");
builder.setPositiveButton("OK",null);
builder.create();
builder.show();

no

la

versin

Primero la creamos y le indicamos cual es la Activity, luego el titulo, mensaje y el boton.

Luego create para modificar los cambios anteriores y el show para mostrarla
Se mostrara hasta que se presione el boton.

AlertDialog con botones de confirmar y

cancelar
Igual pero con dos botones:
//
AlertDialog.Builder dialogo1 = new AlertDialog.Builder(this);
dialogo1.setTitle("Importante");
dialogo1.setMessage(" Acepta la ejecucin de este programa en modo prueba ?");
dialogo1.setCancelable(false);
dialogo1.setPositiveButton("Confirmar", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialogo1, int id) {
aceptar();
}
});
dialogo1.setNegativeButton("Cancelar", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialogo1, int id) {
cancelar();
}
});
dialogo1.show();
//
public void aceptar() {
Toast t=Toast.makeText(this,"Bienvenido a probar el programa.",
Toast.LENGTH_SHORT);
t.show();
}
public void cancelar() {
finish();
}

El principio es igual.
El .setCancelable(false) es para que el AlertDialog no se pueda ser cancelado pulsando cualquier
parte de la pantalla
Los metodos onClick es lo que hace en cada uno de los botones