CACIC Fundesco AndroidYa PDF

La Fundacin para el Desarrollo del Conocimiento, Fundesco, es una entidad sin fines de lucro,
creada en 2001 bajo el lema Educacin en Tecnologa y Tecnologa en Educacin con el fin
de aunar los ideales e intereses de personas y organizaciones que infieran que la tecnologa
es un aporte imprescindible para la educacin de un pas.
Lo realiza a travs de institutos que ha creado al efecto como los de Estudios e investigaciones
en Programacin, Teletrabajo, Seguridad en TICs, Tecnologa y Medio Ambiente, E learning,
Innovacin y Calidad.
En su pgina web www.fundesco.org.ar podrn encontrarse ms detalles sobre los mismos.
IAFIP - Instituto Argentino de Capacitacin e Investigacin en Programacin
Objetivo General
Unir los intereses e ideales de los profesores, investigadores y las partes interesadas que
interpretan que la educacin en materias de iniciacin en la lgica de diseo y programacin,
son los elementos necesarios para lograr que los jvenes puedan tener rpido acceso a la era
digital.
Objetivo particular
Generar y proporcionar cursos de induccin a disciplinas de equipo, con especial

nfasis en la programacin y el diseo.
Ampliar la gama de cursos como progreso de los alumnos en sus conocimientos.
Utilizar cursos presenciales y tecnologas avanzadas en educacin (E- learning, video
streaming, mobile learning, plataformas Web, juegos educativos y otros) para el logro
de estos objetivos.
Crear oportunidades de investigacin a las mejores prcticas en la educacin.
Establecer contacto con otras entidades nacionales e internacionales para participar en
situaciones similares y ayudar financieramente al soporte de estas actividades.
Generar y mantener un sitio Web de libre acceso para los estudiantes, profesores y
personas interesadas.
Difundir las actividades realizadas mediante todos los medios grficos y medios de
impresin.
Participar en programas de radio y televisin para la difusin.
Director General: Dr. Oscar Ricardo Bruno

bruno@fundesco.org.ar
Prximamente
CURSOS y la edicin del libro "Programacin y Algoritmia, un enfoque prctico y
didctico para diseo de algoritmos" escrito por el Dr. Oscar R. Bruno
Instalacin de Android http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=132...
Descarga de herramientas necesarios para programar para Android.

1 - Primero debemos instalar el compilador de Java y la mquina virtual. Estas herramientas las podemos descargar de:
Java SE Development Kit (JDK).
2 - El segundo paso es la descarga del ADT (que contiene todo lo necesario para comenzar el desarrollo de aplicaciones
en Android), lo hacemos del sitio (descargar el de 32 o 64 bit segn el JDK de Java que ya tenemos instalado del paso
anterior):
Android SDK.
3 - El tercer paso es descomprimir el ADT, por ejemplo en la raiz de c:
4 - El cuarto paso es ejecutar el Eclipse:

Nos dirigimos a la carpetas creadas cuando descomprimimos el ADT y vemos que tenemos dos carpetas:
eclipse
sdk
Entramos a la carpeta eclipse y ejecutamos eclipse.exe
Debe aparecer una ventana de inicio similar a esta:
Nos pide seguidamente la carpeta donde deseamos ir almacenando los proyectos que desarrollemos:
Ahora ya estamos en el entorno que tiene una vista similar a esta (recordemos que es el Eclipse con algunos cambios
desarrollados por Google), la primera vez que ingresamos nos aparece una pantalla de bienvenida pero podemos
cerrarla haciendo clic en la cruz de la pestaa y ya tenemos el entorno de trabajo:
1 de 4 30/09/2013 09:45 a.m.

7 - Por ltimo debemos crear el AVD (Android Virtual Device) para ello nos dirigimos a la opcin Window -> Android
Virtual Device Manager.
En este dilogo debemos crear el emulador de Android (presionamos el botn New...):
2 de 4 30/09/2013 09:45 a.m.

En este dilogo asignamos un nombre a nuestro AVD, elegimos un dispositivo (que no sea tan grande ya que no entrara
en pantalla, podemos probar con WVGA(480,800)), lo enlazamos con la versin de SDK respectivo, fijamos un tamao al
SD Card:
3 de 4 30/09/2013 09:45 a.m.

Ya tenemos todo configurado para el desarrollo de aplicaciones Android.
Retornar
4 de 4 30/09/2013 09:45 a.m.

Pasos para crear el primer proyecto Android http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=133...
Ya tenemos todo lo necesario instalado para implementar el primer proyecto. Desde el men de opciones: File -> New ->
Android Application Project
En este dilogo especificamos el nombre de la aplicacin y proyecto (pueden ser iguales) y el nombre del paquete java
donde se almacenarn los archivos java que creemos (normalmente la url de su empresa al revs).
Ahora empezaremos a presionar el botn next para pasar a otras configuraciones de nuestra aplicacin, por el momento
dejaremos todos los valores por defecto en cada una de los dilogos que aparece (son 5 dilogos actualmente), en el
ltimo dilogo debe aparecer el botn "Finish" el cual presionamos.
El ADT nos genera todos los directorios y archivos bsicos para iniciar nuestro proyecto:
1 de 6 30/09/2013 09:46 a.m.

No haremos en este momento un anlisis del significado y objetivo de cada uno de estos directorios y archivos
generados, sino a medida que avancemos con este curso iremos viendo en forma puntual y profunda.
La interfaz visual de nuestro programa para Android se almacena en un archivo XML en la carpeta res, subcarpeta layout
y el archivo se llama activity_main.xml. En esta carpeta tenemos creada nuestra primer pantalla.
Al seleccionar este archivo el ADT nos permite visualizar el contenido en "vista de diseo (Graphical Layout)":
2 de 6 30/09/2013 09:46 a.m.

Si seleccionamos la otra pestaa podemos visualizar el archivo activity_main.xml en formato de texto:
3 de 6 30/09/2013 09:46 a.m.

El ADT ya insert un control de tipo RelativeLayout que permite ingresar controles visuales alineados a los bordes y a
otros controles que haya en la ventana (ms adelante analizaremos este layout)
Ya veremos que podemos modificar todo este archivo para que se adapte a la aplicacin que queremos desarrollar.
Luego contenido en el control RelativeLayout hay otro control de tipo TextView que es bsicamente una etiqueta o label
que mostrar en pantalla el valor almacenado en la propiedad text.
Podemos modificar directamente el archivo xml o en "vista de diseo" modificar los valores de las propiedades. Elegimos
nuevamente la pestaa "Graphical Layout" y seleccionamos el TextView con el mouse y vemos que en la parte derecha
de la pantalla aparece una ventana llamada "properties":
4 de 6 30/09/2013 09:46 a.m.

Y estando seleccionado el TextView buscamos la propiedad Text y cargamos: "Mi primer programa para Android" y
presionamos enter, podemos ver que se actualiza la vista:
Con esto ya podemos probar nuestra primer aplicacin para un dispositivo Android. SELECCIONAMOS con el mouse en
la ventana de la izquierda (Package Explorer) el proyecto001 y presionamos el cono de Run (tringulo verde) o desde el
men. Seleccionamos que se ejecute como aplicacin "Android Application". Ahora se abrir el AVD(Android Virtual
Device) esto tarda bastante tiempo, es muy importante recordar que luego de ver ejecutndose el programa NO debemos
cerrar el AVD para que la prxima ejecucin se inicie ms rpido (podemos minimizar el AVD)
Ahora podemos ver nuestra primer aplicacin corriendo en el emulador de Android:
5 de 6 30/09/2013 09:46 a.m.

Como hemos visto el ADT nos genera en forma automtica todas las carpetas y archivos bsicos que necesitamos en un
principio. En el siguiente concepto podremos empezar a programar verdaderamente. El nico objetivo de este ejercicio es
recordar los pasos para crear un proyecto.
Este proyecto lo puede descargar en un zip desde este enlace: proyecto001.zip
Retornar
6 de 6 30/09/2013 09:46 a.m.

Captura del clic de un botn http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=134...
Problema:
Realizar la carga de dos nmeros en controles de tipo EditText. Mostrar un mensaje que solicite la carga de los valores.
Disponer un Button para sumar los dos valores ingresados. Mostrar el resultado en un tercer TextView.
La interfaz visual debe quedar algo semejante a esto:
Veamos paso a paso como creamos la interfaz visual de nuestro programa. Primero borramos el TextView que aparece
por defecto cuando se crea un proyecto con el ADT. Ahora desde la ventana "Palette" seleccionamos de la pestaa
"Form Widgets" el control "TextView" y lo arrastramos a la ventana de diseo de nuestra interfaz:
1 de 12 30/09/2013 09:46 a.m.

Ahora lo seleccionamos y en la ventana de propiedades especificamos la propiedad text (como habamos visto
anteriormente) disponemos el texto "Ingrese el primer valor:":
2 de 12 30/09/2013 09:46 a.m.

Tambin vamos a especificar la propiedad "Id", la misma aparece primera en la paleta de propiedades y le asignaremos
el valor @+id/tv1 (el nombre es el que se indica luego de la barra es decir cambiamos textView1 por tv1) Cuidado de no
borrar @+id/
Hemos entonces asignado como nombre a este objeto: tv1 (recordemos que se trata de un objeto de la clase TextView)
Ahora de la paleta de componentes seleccionamos la pestaa "Text Fields" y arrastramos el primero (el que tiene la
3 de 12 30/09/2013 09:46 a.m.

etiqueta abc)
En la ventana de properties estando seleccionado el EditText configuramos la propiedad Id... con el nombre et1 (este
nombre haremos referencia posteriormente desde Java)
Efectuamos los mismos pasos para crear el segundo TextView y EditText (inicializamos las propiedades respectivas)
Definimos los id con los nombres tv2 y et2, el resultado visual debe ser algo semejante a esto:
4 de 12 30/09/2013 09:46 a.m.

De la pestaa "Form Widgets" arrastramos un control de tipo "Button":
5 de 12 30/09/2013 09:46 a.m.

Inicializamos la propiedad text con el texto "Sumar" y la propiedad id la dejamos con el valor ya creado llamado
"button1".
Para terminar con nuestra interfaz visual arrastramos un tercer objeto de tipo TextView y definimos la propiedad id con el
valor "tv3" y la propiedad text con el texto "resultado", recordemos que la interfaz final debe ser semejante a esta:
Si en este momento ejecutamos la aplicacin aparece la interfaz visual correctamente pero cuando presionemos el botn
no mostrar la suma.
Es fundamental una vez finalizada la interfaz visual proceder a grabarla (icono de los diskettes) o la opcin
File->Save para que se actualicen los archivos que se generan automticamente.
Hasta ahora hemos trabajado solo con el archivo xml (activity_main.xml) donde se definen los controles visuales de la
ventana que estamos creando.
Abrimos seguidamente el archivo MainActivity.java que lo podemos ubicar en la carpeta src:
6 de 12 30/09/2013 09:46 a.m.

La clase MainActivity hereda de la clase Activity. La clase Activity representa una ventana de Android y tiene todos los
mtodos necesarios para crear y mostrar los objetos que hemos dispuesto en el archivo xml.
El cdigo fuente de la clase MainActivity.java es:
package com.javaya.proyecto002;
import android.os.Bundle;
import android.app.Activity;
import android.view.Menu;
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.activity_main, menu);
return true;
}
Como mnimo se debe sobrescribir el mtodo onCreate heredado de la clase Activity donde procedemos a llamar la
mtodo setContentView pasando como referencia una valor almacenado en una constante llamada activity_main
contenida en una clase llamada layout que a su vez la contiene una clase llamada R (veremos ms adelante que el ADT
se encarga de crear la clase R en forma automtica y sirve como puente entre el archivo xml y nuestra clase MainActivity)
Luego veremos el otro mtodo onCreateOptionsMenu.
7 de 12 30/09/2013 09:46 a.m.

Captura de eventos.
Ahora viene la parte donde definimos variables en java donde almacenamos las referencias a los objetos definidos en el
archivo XML.
Definimos tres variables, dos de tipo EditText y finalmente una de tipo TextView (estas dos clases se declaran en el
paquete android.widget, es necesario importar dichas clases para poder definir las variables de dichas clases):
import android.widget.EditText;
import android.widget.TextView;
private EditText et1,et2;

private TextView tv3;
@Override
}
@Override
return true;
}
La forma ms fcil de importar las clases EditText y TextView es tipear las dos lneas:

y luego presionar las teclas Control-Shift-O

Esto hace que se escriban automticamente los dos import:
Los nombres que le d a los objetos en este caso coinciden con la propiedad id (no es obligatorio):

No definimos TextView para los dos mensajes "Ingrese el primer valor" e "Ingrese el segundo valor" ya que no
necesitaremos interactuar con ellos. Tambin veremos que el objeto de la clase Button no es necesario definir un atributo
sino que desde el archivo XML inicializaremos la propiedad OnClick.
En el mtodo onCreate debemos enlazar estas variables con los objetos definidos en el archivo XML, esto se hace
llamando al mtodo findViewById:
public void onCreate(Bundle savedInstanceState) {

setContentView(R.layout.main);
et1=(EditText)findViewById(R.id.et1);
8 de 12 30/09/2013 09:46 a.m.

tv3=(TextView)findViewById(R.id.tv3);
}
Al mtodo findViewById debemos pasar la constante creada en la clase R (recordemos que se crea automticamente
esta clase) el nombre de la constante si debe ser igual con el nombre de la propiedad del objeto creado en el archivo
XML. Como la clase findViewById retorna una clase de tipo View luego debemos utilizar el operador cast (es decir le
antecedemos entre parntesis el nombre de la clase)
Ya tenemos almacenados en las variables las referencias a los tres objetos que se crean al llamar al
mtodo:setContentView(R.layout.main); .
Ahora planteamos el mtodo que se ejecutar cuando se presione el botn (el mtodo debe recibir como parmetro un
objeto de la clase View) En nuestro ejemplo lo llam sumar:
import android.view.View;

@Override
}
@Override
return true;
}
//Este mtodo se ejecutar cuando se presione el botn

public void sumar(View view) {
Debemos importar lar clase View (Control-Shift-O)
Ahora debemos ir al archivo XML e inicializar la propiedad OnClick del objeto button1 con el nombre del mtodo que
acabamos de crear (este paso es fundamental para que el objeto de la clase Button pueda llamar al mtodo sumar que
acabamos de crear):
9 de 12 30/09/2013 09:46 a.m.

Finalmente implementaremos la lgica para sumar los dos valores ingresados en los controles EditText:

String valor1=et1.getText().toString();
int nro1=Integer.parseInt(valor1);
int suma=nro1+nro2;
String resu=String.valueOf(suma);
tv3.setText(resu);
}
Extraemos el texto de los dos controles de tipo EditText y los almacenamos en dos variables locales de tipo String.
Convertimos los String a tipo entero, los sumamos y el resultado lo enviamos al TextView donde se muestra la suma
(previo a convertir la suma a String)
La clase completa queda entonces como:

@Override
10 de 12 30/09/2013 09:46 a.m.

}
@Override
return true;
}

int suma=nro1+nro2;
tv3.setText(resu);
}
Si ejecutamos nuestro programa podemos ver ahora que luego de cargar dos valores al presionar el botn aparece en el
tercer TextView el resultado de la suma de los dos EditText:
11 de 12 30/09/2013 09:46 a.m.

Retornar
12 de 12 30/09/2013 09:46 a.m.

Controles RadioGroup y RadioButton http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=135...
El objetivo de este concepto es practicar la implementacin de un programa que requiera controles de tipo RadioButton
para seleccionar una actividad. Aprenderemos como agrupar un conjunto de RadioButton y verificar cual est
seleccionado.
Problema:
Disponer dos controles de tipo RadioButton para seleccionar si queremos sumar o restar dichos valores. Finalmente
mediante un control de tipo Button efectuamos la operacin respectiva. Mostramos el resultado en un TextView.
El problema es similar al anterior. Para disponer los controles de tipo RadioButton debemos en realidad primero insertar
un control de tipo RadioGroup (este control se encuentra en la paleta de componentes en la pestaa Form Widgets):
Cuando arrastramos el control RadioGroup al formulario se generan automticamente 3 objetos de la clase RadioButton
contenidos dentro del RadioGroup, podemos fcilmente identificar que los controles RadioButton pertenecen a dicho
RadioGroup viendo la ventana de "Outline" del Eclipse (donde nos muestra todos los controles insertados hasta el
momento):
1 de 4 30/09/2013 09:47 a.m.

Nuestro problema solo requiere dos controles de tipo RadioButton. Para borrarlo lo podemos hacer directamente del
formulario seleccionndolo y presionando la tecla delete o seleccionndolo desde la ventana "Outline" y luego
presionando la tecla delete
.
Ahora a los dos controles de tipo RadioButton definimos sus id (los llamaremos r1 y r2 respectivamente)
Cambiamos sus propiedades text por los textos "sumar" y "restar".
No olvidemos tambin cambiar los id de los controles EditText por et1 y et2 (igual que en el problema anterior)
Por ltimo agreguemos un botn y un TextView para mostrar el resultado

Inicializamos las propiedades del botn con los valores:
id : button1
text : operar
Y el tercer TextView con los valores:
id : tv3
text : resultado
Podemos controlar en la ventana "Outline" el id definido para cada control (tv1, et1, tv2, et2, radioGroup1, r1, r2, button1,
tv3)
Tambin podemos observar de que clase es cada control visual y el texto de la propiedad text para aquellos controles
que tienen sentido su inicializacin.
2 de 4 30/09/2013 09:47 a.m.

Si nuestro problema requera ms de 3 RadioButton deberamos arrastrar dentro del RadioGroup otros controles de tipo
RadioButton que se encuentran tambin en la pestaa de "Form Widgets"
Captura del evento clic del button e identifiacin del RadioButton seleccionado.
El cdigo fuente de la clase MaintActivity es:
import android.widget.RadioButton;

private RadioButton r1,r2;
@Override
3 de 4 30/09/2013 09:47 a.m.

r1=(RadioButton)findViewById(R.id.r1);
}
@Override
return true;
}

public void operar(View view) {
if (r1.isChecked()==true) {
int suma=nro1+nro2;
tv3.setText(resu);
} else
int resta=nro1-nro2;
String resu=String.valueOf(resta);
tv3.setText(resu);
}
}
Primero debemos enlazar el objeto button1 con el mtodo operar. Para esto similar al problema anterior seleccionamos el
control button1 y cambiamos la propiedad OnClick por el valor operar (si no hacemos esto nunca se ejecutar el mtodo
operar de la clase MainActivity)
Como podemos ver el cdigo fuente es igual al problema anterior. Tenemos dos objetos ms que debemos inicializar en
el mtodo onCreate:
Las variables r1 y r2 son de la clase RadioButton y son necesarios en el mtodo operar para verificar cual de los dos
RadioButton estn seleccionados. La clase RadioButton tiene un mtodo llamado isChecked que retorna true si dicho
elemento est seleccionado:

int suma=nro1+nro2;
tv3.setText(resu);
} else
tv3.setText(resu);
}
}
Retornar
4 de 4 30/09/2013 09:47 a.m.

Control CheckBox http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=136...
El objetivo de este concepto es practicar lo visto hasta ahora e incorporar el control visual CheckBox
Problema:
Disponer dos controles de tipo CheckBox para seleccionar si queremos sumar y/o restar dichos valores. Finalmente
mediante un control de tipo Button efectuamos la operacin respectiva. Mostramos el o los resultados en un TextView.
Lo nuevo en este problema es la insercin de dos objetos de la clase CheckBox que se encuentra en la pestaa "Form
Widgets":
Luego la interfaz grfica final para este problema y los nombres de los controles los podemos ver en la ventana "Outline":
1 de 3 30/09/2013 09:47 a.m.

No olvidemos inicializar la propiedad OnClick del objeto button1 con el valor "operar" (es el nombre del mtodo a
ejecutarse cuando se presione el botn y lo implementa la clase que hacemos)
Cdigo fuente:
package com.androiya.proyecto004;
import android.widget.CheckBox;

private CheckBox checkBox1,checkBox2;
@Override
checkBox1=(CheckBox)findViewById(R.id.checkBox1);
}
2 de 3 30/09/2013 09:47 a.m.

@Override
return true;
}

String resu="";
if (checkBox1.isChecked()==true) {
int suma=nro1+nro2;
resu="La suma es: "+ suma;
}
resu=resu + " La resta es: "+ resta;
}
tv3.setText(resu);
}
Definimos dos objetos de la clase CheckBox como atributos de la clase:
private CheckBox checkBox1,checkBox2;
En el mtodo onCreate los inicializamos con los objetos definidos en el archivo XML:
En el mtodo operar debemos definir dos if a la misma altura ya que los dos controles de tipo CheckBox pueden estar
seleccionados simultaneamente. Definimos una variable de tipo String y la inicializamos con cadena vaca para el caso en
que los dos CheckBox no estn seleccionados:
String resu="";
int suma=nro1+nro2;
resu="La suma es: "+ suma;
}
resu=resu + " La resta es: "+ resta;
}
tv3.setText(resu);
Retornar
3 de 3 30/09/2013 09:47 a.m.

Control Spinner http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=137...
El objetivo de este concepto es practicar lo visto hasta ahora e incorporar el control visual Spinner
El control Spinner muestra una lista de String y nos permite seleccionar uno de ellos. Cuando se lo selecciona se abre y
muestra todos sus elementos para permitir seleccionar uno de ellos.
Problema:
Disponer un control de tipo Spinner que permita seleccionar si queremos sumar, restar, multiplicar o dividir dichos
valores. Finalmente mediante un control de tipo Button efectuamos la operacin respectiva. Mostramos el resultado en
un TextView.
Lo nuevo en este problema es la insercin de un control de tipo Spinner que se encuentra en la pestaa "Form Widgets":
Definimos la propiedad id con el valor spinner1 (valor por defecto).
En la siguiente imagen en la ventana "Outline" de Eclipse podemos observar los objetos dispuestos en el formulario, sus
Id, sus textos y de que clase son cada uno:
1 de 4 30/09/2013 09:47 a.m.

No olvidemos inicializar la propiedad OnClick del objeto button1 con el valor "operar" (dicho nombre es el mtodo que
debemos implementar)
Cdigo fuente:
import android.widget.ArrayAdapter;
import android.widget.Spinner;

private Spinner spinner1;
@Override
spinner1 = (Spinner) findViewById(R.id.spinner1);

String []opciones={"sumar","restar","multiplicar","dividir"};
2 de 4 30/09/2013 09:47 a.m.

ArrayAdapter<String> adapter = new ArrayAdapter<String>(this,android.R.layo

spinner1.setAdapter(adapter); }
@Override
return true;
}

String selec=spinner1.getSelectedItem().toString();
if (selec.equals("sumar")) {
int suma=nro1+nro2;
tv3.setText(resu);
} else
if (selec.equals("restar")) {
tv3.setText(resu);
}
else
if (selec.equals("multiplicar")) {
int multi=nro1*nro2;
String resu=String.valueOf(multi);
tv3.setText(resu);
}
else
if (selec.equals("dividir")) {
int divi=nro1/nro2;
String resu=String.valueOf(divi);
tv3.setText(resu);
}
}
Definimos un objeto de la clase Spinner:
private Spinner spinner1;
En el mtodo onCreate obtenemos la referencia al control visual declarado en el archivo XML:
spinner1=(Spinner)findViewById(R.id.spinner1);
Definimos un vector con la lista de String que mostrar el Spinner:
String []opciones={"sumar","restar","multiplicar","dividir"};
Definimos y creamos un objeto de la clase ArrayAdapter:
ArrayAdapter<String> adapter = new ArrayAdapter<String>(this,android.R.layout.simple_spinner_
Al constructor le pasamos como primer parmetro la referencia de nuestro Activity (this), el segundo parmetro indica el
tipo de Spinner, pudiendo ser las constantes:
android.R.layout.simple_spinner_item
android.R.layout.simple_spinner_dropdown_item
3 de 4 30/09/2013 09:47 a.m.

El tercer parmetro es la referencia del vector que se mostrar:
Luego llamamos al mtodo setAdapter de la clase Spinner pasando la referencia del objeto de la clase ArrayAdapter que
acabamos de crear:
spinner1.setAdapter(adapter);
En el mtodo operar que se ejecuta cuando presionamos el botn procedemos a extraer el contenido seleccionado del
control Spinner:
String selec=spinner1.getSelectedItem().toString();
Luego mediante una serie de if anidados verificamos si debemos sumar, restar, multiplicar o dividir:
if (selec.equals("sumar")) {
int suma=nro1+nro2;
tv3.setText(resu);
} else
if (selec.equals("restar")) {
tv3.setText(resu);
}
else
if (selec.equals("multiplicar")) {
int multi=nro1*nro2;
String resu=String.valueOf(multi);
tv3.setText(resu);
}
else
if (selec.equals("dividir")) {
int divi=nro1/nro2;
String resu=String.valueOf(divi);
tv3.setText(resu);
}
Retornar
4 de 4 30/09/2013 09:47 a.m.

Control ListView http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=138...
El control ListView a diferencia del Spinner que se cierra luego de seleccionar un elemento permanecen visibles varios
elementos (se lo utiliza cuando hay que mostrar muchos elementos)
Si la lista no entra en el espacio que hemos fijado para el ListView nos permite hacer scroll de los mismos.
El control ListView se encuentra en la pestaa "Compositive".
Problema:
Disponer un ListView con los nombres de paises de sudamrica. Cuando se seleccione un pas mostrar en un TextView la
cantidad de habitantes del pas seleccionado.
La interfaz visual a implementar es la siguiente (primero disponemos un TextView (llamado tv1) y un ListView (llamado
listView1)):
Cdigo fuente:
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ArrayAdapter;
import android.widget.ListView;
1 de 3 30/09/2013 09:47 a.m.


private String[] paises = { "Argentina", "Chile", "Paraguay", "Bolivia",
"Peru", "Ecuador", "Brasil", "Colombia", "Venezuela", "Urug
private String[] habitantes = { "40000000", "17000000", "6500000",
"10000000", "30000000", "14000000", "183000000", "44000000"
"29000000", "3500000" };
private ListView lv1;
@Override
lv1 =(ListView)findViewById(R.id.listView1);
ArrayAdapter <String> adapter = new ArrayAdapter<String>(this,android.R.lay
lv1.setAdapter(adapter);
lv1.setOnItemClickListener(new OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> parent, View v, int posicion, lo
tv1.setText("Poblacin de "+ lv1.getItemAtPosition(posicion) + " es
}
});
}
@Override
// Inflate the menu; this adds items to the action bar if it is pre
return true;
}
Primero definimos dos vectores paralelos donde almacenamos en uno los nombres de paises y en el otro almacenamos
la cantidad de habitantes de dichos paises:
private String[] paises={"Argentina","Chile","Paraguay","Bolivia","Peru",

"Ecuador","Brasil","Colombia","Venezuela","Uruguay"};
private String[] habitantes={"40000000","17000000","6500000","10000000","30000000",
"14000000","183000000","44000000","29000000","3500000"};
Definimos un objeto de tipo TextView y otro de tipo ListView donde almacenaremos las referencias a los objetos que
definimos en el archivo XML:

private ListView lv1;
En el mtodo onCreate obtenemos la referencia a los dos objetos:
lv1 =(ListView)findViewById(R.id.listView1);
Creamos un objeto de la clase ArrayAdapter de forma similar a como lo hicimos cuando vimos la clase Spinner:
ArrayAdapter<String> adapter = new ArrayAdapter<String>(this,android.R.layout.simple_list_ite

lv1.setAdapter(adapter);
Llamamos al mtodo setOnItemClicListener de la clase ListView y le pasamos como parmetro una clase annima que
implementa la interfaz OnItemClickListener (dicha interfaz define el mtodo onItemClick que se dispara cuando
seleccionamos un elemento del ListView):
lv1.setOnItemClickListener(new OnItemClickListener() {
2 de 3 30/09/2013 09:47 a.m.

@Override
public void onItemClick(AdapterView<?> parent, View v, int posicion, long id) {
tv1.setText("Poblacin de "+ lv1.getItemAtPosition(posicion) + " es "+ habitantes[pos
}
});
Dentro del mtodo onItemClick modificamos el contenido del TextView con el nombre del pas y la cantidad de habitantes
de dicho pas. Este mtodo recibe en el tercer parmetro la posicin del item seleccionado del ListView.
Cuando ejecutamos el proyecto podemos ver una interfaz en el emulador similar a esta:
Retornar
3 de 3 30/09/2013 09:47 a.m.

Control ImageButton http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=139...
Hemos visto la creacin de objetos de la clase Button, ahora veremos otra clase muy similar a la anterior llamada
ImageButton que tiene la misma filosofa de manejo con la diferencia que puede mostrar una imagen en su superficie.
Problema:
Disponer un objeto de la clase ImageButton que muestre una imagen de un telfono. Cuando se presione mostrar en un
control TextView el mensaje "Llamando".
Primero crearemos un proyecto llamado proyecto007 y luego debemos buscar una imagen en formato png que
represente un telefono de 50*50 pxeles.
Nombre del archivo: telefono.png
Ahora copiamos el archivo a la carpeta de recursos de nuestro proyecto : res\drawable-mdpi
Desde el Eclipse en la ventana "Package Explorer" navegamos hasta la carpeta res y entramos al directorio
drawable-mdpi y vemos que todava no est el archivo que acabamos de copiar. Para que se actualice el proyecto
presionamos el botn derecho del mouse sobre esta carpeta y seleccionamos la opcin "Refresh":
Vemos que se actualiz el contenido de la carpeta y aparece la imagen que copiamos previamente.
Ahora insertaremos el objeto de la clase ImageButton en el formulario de nuestra aplicacin. La clase ImageButton se
encuentra en la pestaa "Image & Media":
1 de 4 30/09/2013 09:47 a.m.

Aparece un dilogo de donde seleccionamos el archivo telefono. Luego de esto podemos ver que la superficie del objeto
de la clase ImageButton muestra la imagen que almacenamos previamente en la carpeta de res.
Si queremos cambiar el archivo a mostrar debemos modificar la propiedad src (aparece nuevamente el dilogo que nos
permite seleccionar la imagen)
Inicializamos la propiedad ID con el nombre bi1
Agreguemos un TextView a nuestra aplicacin y configuremos sus propiedades ID (con tv1) y text. Luego la interfaz visual
debe ser similar a:
2 de 4 30/09/2013 09:47 a.m.

Cdigo fuente:

@Override
}
@Override
return true;
}
//Este mtodo se ejecutar cuando se presione el ImageButton

public void llamar(View view) {
tv1.setText("Llamando");
}
3 de 4 30/09/2013 09:47 a.m.

Definimos el atributo de tipo TextView:
TextView tv1;
Enlazamos el control definido en el archivo XML y la variable de java:
Implementamos el mtodo que se ejecutar cuando se presione el el objeto de la clase ImageButton:
public void llamar(View view) {

tv1.setText("Llamando");
}
No olvidemos inicializar la propiedad OnClick del objeto ib1 con el nombre del mtodo "llamar" (recordemos que esto lo
hacemos accediendo a la propiedad On Click en la ventana de "Properties")
Comentarios extras de este control.
Cuando copiamos el archivo lo hicimos a la carpeta:
drawable-mdpi
Pero vimos que hay otras carpetas con nombres similares:
drawable-ldpi
drawable-hdpi
El objetivo de estas otras carpetas es guardar las mismas imgenes pero con una resolucin mayor si la guardamos en
drawable-hdpi y con una resolucin menor al guardarla en drawable-ldpi.
Esto se hace si queremos que nuestra aplicacin sea ms flexible si se ejecuta en un celular, en un tablet, en un
televisor etc.
Debemos tener en cuenta estos tamaos:
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)
Retornar
4 de 4 30/09/2013 09:47 a.m.

Lanzar un segundo "Activity" y pasar parmetros. http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=141&in...
Hemos visto en el concepto anterior que un programa puede tener ms de una ventana representando cada ventana con
una clase que hereda de Activity.
Una situacin muy comn es que la primer ventana necesite enviar datos a la segunda para que a partir de estos
proceda a efectuar una accin.
Problema:
Confeccionar un programa que solicite el ingrese de una direccin de un sitio web y seguidamente abrir una segunda
ventana que muestre dicha pgina.
Para resolver este problema utilizaremos el control visual WebView que nos permite mostrar el contenido de un sitio web.
Crearemos un nuevo proyecto llamado proyecto010 y lo almacenaremos en el package name:

com.androidya.proyecto010.
1 - Nuestro primer Activity tendr la siguiente interfaz visual (ver controles y ID de los controles):
Tenemos un control de tipo TextView (tv1), otro de tipo EditText y finalmente otro de tipo Button (button1) debemos
inicializar las propiedades de cada uno de estos tres objetos.
El cdigo fuente de esta Activity es:
1 de 6 30/09/2013 09:59 a.m.

package com.androidya.proyecto010;
import android.content.Intent;

private EditText et1;
@Override
et1 = (EditText) findViewById(R.id.et1);

}
@Override
return true;
}
public void ejecutar(View view) {

Intent i = new Intent(this, Actividad2.class);
i.putExtra("direccion", et1.getText().toString());
startActivity(i);
}
Como podemos ver la diferencia con el concepto anterior es que llamamos al mtodo putExtra de la clase Intent. Tiene
dos parmetros de tipo String, en el primero indicamos el nombre del dato y en el segundo el valor del dato:
public void ejecutar(View view) {

Intent i = new Intent(this, Actividad2.class );
i.putExtra("direccion", et1.getText().toString());
startActivity(i);
}
La segunda interfaz visual (recordemos que debemos presionar el botn derecho sobre la carpeta layout y seleccionar la
opcin New -> Android XML File) la llamaremos actividad2.xml:
2 de 6 30/09/2013 09:59 a.m.

En esta interfaz disponemos primero un control de tipo Button (button1) y un objeto de la clase WebView (se encuentra
en la pestaa "Composite") y lo dejamos con el ID por defecto llamado webView1
Tenemos que crear el archivo Java donde dispondremos la funcionalidad de la segunda ventana (Activity)
Creamos una nueva clase al proyecto desde el men contextual(presionamos el botn derecho del mouse sobre el
paquete com.androidya.proyecto010)
Al nombre de la clase la llamamos Actividad2 y debemos especificar que hereda de la clase android.app.Activity
Ahora tenemos que modificar el archivo Java generado agregando del mtodo onCreate con esto:
import android.webkit.WebView;
public class Actividad2 extends Activity {

private WebView webView1;
@Override
// TODO Auto-generated method stub
setContentView(R.layout.actividad2);
3 de 6 30/09/2013 09:59 a.m.

webView1 = (WebView) findViewById(R.id.webView1);
Bundle bundle = getIntent().getExtras();

webView1.loadUrl("http://" + bundle.getString("direccion"));
}
public void finalizar(View view) {

finish();
}
}
En esta clase definimos una variable de tipo Bundle y la inicializamos llamando al mtodo getExtras() de la clase Intent
(esto lo hacemos para recuperar el o los parmetros que envi la otra actividad (Activity)):
Bundle bundle=getIntent().getExtras();
webView1.loadUrl("http://"+bundle.getString("direccion"));
El mtodo loadUrl de la clase WebView permite visualizar el contenido de un sitio web.
Otro paso fundamental es registrar el Activity en el archivo "AndroidManifest.xml" que se encuentra en la raiz principal del
proyecto.
Seleccionamos el archivo y activamos la pestaa : "Application", presionamos el botn "add" y seleccionamos "Activity".
Por ltimo seleccionamos en "Application Nodes" la actividad creada y definimos la propiedad Name con el nombre de la
clase que la implementa (en nuestro caso se llama Actividad2)
Como nuestra aplicacin debe acceder a internet debemos hacer otra configuracin en el archivo "AndroidManifest.xml",
debemos ir a la pestaa "Permissions" presionar el botn "Add" y seleccionar "Uses Permissions":
Luego fijar en la propiedad name el valor android.permission.INTERNET
Ahora nuestro programa debera estar funcionando completamente.
La primer ventana debera ser algo similar a esto:
4 de 6 30/09/2013 09:59 a.m.

La segunda ventana debera ser algo similar a esto otro:
5 de 6 30/09/2013 09:59 a.m.

Retornar
6 de 6 30/09/2013 09:59 a.m.

Almacenamiento de datos mediante la clase SharedPreferences http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=142&in...
Veremos que la plataforma de Android nos da varias facilidades para el almacenamiento permanente de datos (es decir
que los mismos no se borran cuando se apaga la aplicacin)
Segn el tipo de necesidades utilizaremos alguno de estos mtodos:
1. Mediante la clase SharedPreferences.
2. Mediante archivos de Texto.
3. En una base de datos.
No ser raro que una aplicacin utilice ms de uno de estos mtodos para el almacenamiento de datos.
Cuando tenemos que almacenar una cantidad limitada de datos es adecuado utilizar la clase SharedPreferences. Por
ejemplo configuraciones de la aplicacin como pueden ser colores de pantalla, nivel actual en un juego, datos iniciales
de controles de entrada de dato etc.
Problema:
Confeccionar un programa que solicite el ingrese del mail de una persona. Guardar el mail ingresado utilizando la clase
SharedPreferences. Cada vez que se inicie la aplicacin almacenar en el control EditText el ltimo mail ingresado.
Disponer un botn para almacenar el mail ingresado y finalizar el programa.
Crearemos un nuevo proyecto llamado proyecto011 y lo almacenaremos en el package name:

La interfaz visual a implementar y los Id de los controles visuales son los siguientes:
1 de 5 30/09/2013 10:01 a.m.

Es decir:
Disponemos un TextView y definimos su ID con el nombre tv1

la propiedad Text con "Ingrese el mail:".
Disponemos un EditText y definimos su ID con el nombre et1.

Disponemos un Button y definimos su propiedad Id con el nombre button1
su propiedad Text con el valor confirmar
su propiedad OnClic con el valor ejecutar
El cdigo java es:
import android.content.Context;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;

2 de 5 30/09/2013 10:01 a.m.

@Override
SharedPreferences prefe=getSharedPreferences("datos",Context.MODE_PRIVATE);
et1.setText(prefe.getString("mail",""));
}
@Override
return true;
}
public void ejecutar(View v) {

SharedPreferences preferencias=getSharedPreferences("datos",Context.MODE_PR
Editor editor=preferencias.edit();
editor.putString("mail", et1.getText().toString());
editor.commit();
finish();
}
Obtenemos la referencia del EditText:
Obtenemos una referencia de un objeto de la clase SharedPreferences a travs del mtodo getSharedPreferences. El
primer parmetro es el nombre del archivo de preferencias y el segundo la forma de creacin del archivo
(MODE_PRIVATE indica que solo esta aplicacin puede consultar el archivo XML que se crea)
SharedPreferences prefe=getSharedPreferences("datos",Context.MODE_PRIVATE);
Para extraer los datos del archivo de preferencias debemos indicar el nombre a extraer y un valor de retorno si dicho
nombre no existe en el archivo de preferencias (en nuestro ejemplo la primera vez que se ejecute nuestro programa
como es lgico no existe el archivo de preferencias lo que hace que Android lo cree, si tratamos de extraer el valor de
mail retornar el segundo parmetro es decir el String con una cadena vaca:
et1.setText(prefe.getString("mail",""));
Cuando se presiona el botn "Confirmar" lo que hacemos es grabar en el archivo de preferencias el contenido del
EditText en una variable llamada "mail":

SharedPreferences preferencias=getSharedPreferences("datos",Context.MODE_PRIVATE);
Editor editor=preferencias.edit();
editor.putString("mail", et1.getText().toString());
editor.commit();
finish();
}
Debemos crear un objeto de la clase Editor y obtener la referencia del objeto de la clase SharedPreferences que
acabamos de crear. Mediante el mtodo putString almacenamos en mail el valor del String cargado en el EditText. Luego
3 de 5 30/09/2013 10:01 a.m.

debemos llamar al mtodo commit de la clase editor para que el dato quede almacenado en forma permanente en el
archivo de preferencias. Esto hace que cuando volvamos a arrancar la aplicacin se recupere el ltimo mail ingresado.
Recordemos que el mtodo finish de la clase Activity finaliza la actividad actual (como tenemos una aplicacin con una
sola actividad finalizar completamente nuestro programa.
Comentarios extras.
El modo de operacin del archivo puede ser:
MODE_PRIVATE solo la aplicacin puede acceder al archivo de preferencias.
MODE_WORLD_READABLE otras aplicaciones pueden consultar el archivo de preferencias
MODE_WORLD_WRITEABLE otras aplicaciones pueden consultar y modificar el archivo.
MODE_MULTI_PROCESS varios procesos pueden acceder (Requiere Android 2.3)
Cuando guardamos datos en el archivo de preferencias podemos almacenar distintos tipos de datos segn el mtodo
que llamemos en el momento de grabar:
editor.putInt("edad",3);
editor.putBoolean("activo", true);
editor.putFloat("altura", 2.3f);
Cuando los recuperamos debemos indicar tambin que tipo de datos extraemos:
int e=prefe.getInt("edad", 0);

boolean acti=prefe.getBoolean("activo", false);
float alt=prefe.getFloat("altura", 0f);
Problema propuesto
1. Realizar un programa que genere un nmero aleatorio entre 1 y 50, pedir que el operador lo adivine, informar si gan
o si el nmero es mayor o menor al ingresado. Cuando el operador lo adivine incrementar en uno el puntaje de
juego. Cada vez que se ingrese a la aplicacin mostrar el puntaje actual, es decir recordar el puntaje en un archivo
de preferencias.
La interfaz visual de la aplicacin a desarrollar es:
4 de 5 30/09/2013 10:01 a.m.

Retornar
5 de 5 30/09/2013 10:01 a.m.

Almacenamiento de datos en un archivo de texto en la memoria interna. http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=143&in...
Otra posibilidad de almacenar datos en nuestro dispositivo Android es el empleo de un archivo de texto que se guardar
en el almacenamiento interno del equipo (la otro posibilidad es almacenarlo en una tarjeta SD Card)
Problema:
Confeccionar un programa que permita almacenar notas en un control EditText y cuando se presione un botn
almacenar los datos del EditText en un archivo de texto llamado "notas.txt".
Cada vez que se ingrese al programa verificar si existe el archivo de textos "notas.txt" proceder a su lectura y
almacenamiento de datos en el EditText.
Crear un proyecto en Eclipse de tipo "Android Project" y definir como nombre: proyecto013 y localizarlo en el paquete
La interfaz visual, los controles y sus ID son los siguientes:
El cdigo fuente de la aplicacin:
1 de 4 30/09/2013 10:01 a.m.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import android.widget.Toast;

@Override
et1 = (EditText) findViewById(R.id.et1);

String[] archivos = fileList();
if (existe(archivos, "notas.txt"))
try {
InputStreamReader archivo = new InputStreamReader(
openFileInput("notas.txt"));
BufferedReader br = new BufferedReader(archivo);
String linea = br.readLine();
String todo = "";
while (linea != null) {
todo = todo + linea + "\n";
linea = br.readLine();
}
br.close();
archivo.close();
et1.setText(todo);
} catch (IOException e) {
}
}
@Override
return true;
}
private boolean existe(String[] archivos, String archbusca) {

for (int f = 0; f < archivos.length; f++)
if (archbusca.equals(archivos[f]))
return true;
return false;
}
public void grabar(View v) {

try {
OutputStreamWriter archivo = new OutputStreamWriter(openFileOutput(
"notas.txt", Activity.MODE_PRIVATE));
archivo.write(et1.getText().toString());
2 de 4 30/09/2013 10:01 a.m.

archivo.flush();
archivo.close();
}
Toast t = Toast.makeText(this, "Los datos fueron grabados",
Toast.LENGTH_SHORT);
t.show();
finish();
}
}
Veamos primero como grabamos datos en un archivo de texto. Esto se hace en el mtodo grabar que se ejecuta cuando
presionamos el botn "grabar" (recordemos de inicializar la propiedad "OnClick" del botn):

try {
OutputStreamWriter archivo = new OutputStreamWriter(openFileOutput("notas.txt",Activity.M
Creamos un objeto de la clase OutputStreamWriter y al constructor de dicha clase le enviamos el dato que retorna el
mtodo openFileOutput propio de la clase Activity que le pasamos como parmetro el nombre del archivo de texto y el
modo de apertura.
Seguidamente si el archivo se cre correctamente procedemos a llamar al mtodo write y le pasamos el String a grabar,
en este caso extraemos los datos del EditText:
archivo.write(et1.getText().toString());
Luego de grabar con el mtodo write llamamos al mtodo flush para que vuelque todos los datos que pueden haber
quedado en el buffer y procedemos al cerrado del archivo:
archivo.flush();
archivo.close();
Todo esto est cerrado en un try/catch para verificar si sucede algn error en la apertura del archivo.
Finalmente mostramos un mensaje temporal en pantalla utilizando la clase Toast:
Toast t=Toast.makeText(this,"Los datos fueron grabados", Toast.LENGTH_SHORT);

t.show();
finish();
Para crear un objeto de la clase Toast llamamos al mtodo makeText de la clase Toast y le pasamos la referencia del
Activity actual, el String a mostrar y el tiempo de duracin del mensaje. Con el objeto devuelto por el mtodo makeText
procedemos a llamar seguidamente al mtodo show para que se muestre el mensaje.
Es comn llamar al mtodo show de la clase Toast en una sola lnea como esta:
Toast.makeText(this,"Los datos fueron grabados", Toast.LENGTH_SHORT).show();
El mtodo onCreate tiene por objetivo verificar si existe el archivo de texto, proceder a su lectura y mostrar su contenido
en el EditText.
Primero obtenemos la lista de todos los archivos creados por la Activity. En nuestro ejemplo puede ser cero o uno:
String []archivos=fileList();
Llamamos a un mtodo que verifica si en el vector de tipo String existe el archivo "notas.txt":
if (existe(archivos,"notas.txt"))
3 de 4 30/09/2013 10:01 a.m.

En el caso que me retorne true procedemos a crear un objeto de la clase InputStreamReader y al constructor de dicha
clase le pasamos el dato devuelto por el mtodo openFileInput:
InputStreamReader archivo=new InputStreamReader(openFileInput("notas.txt"));
Creamos un objeto de la clase BufferedReader y le pasamos al constructor la referencia del objeto de la clase
InputStreamReader:
BufferedReader br=new BufferedReader(archivo);
Leemos la primer lnea del archivo de texto:
String linea=br.readLine();
Inicializamos un String vaco:
String todo="";
Mientras el mtodo readLine de la clase BufferedReader devuelva un String:
while (linea!=null)
{
Lo concatenamos al String junto a un salto de lnea:
todo=todo+linea+"\n";
Leemos la prxima lnea:
linea=br.readLine();
}
Llamamos al mtodo close de la clase BufferedReader y al del InputStreamReader:
br.close();
archivo.close();
Cargamos el EditText con el contenido del String que contiene todos los datos del archivo de texto:
et1.setText(todo);
El mtodo existe llega un vector de tipo String y otro String a buscar. Dentro de un for verificamos el String a buscar con
cada uno de los String del vector, si lo encontramos retornamos true. Si recorre todo el for sin encontrarlo fuera del for
retornamos false:
private boolean existe(String[] archivos,String archbusca)

{
for(int f=0;f<archivos.length;f++)
if (archbusca.equals(archivos[f]))
return true;
return false;
}
Retornar
4 de 4 30/09/2013 10:01 a.m.

Almacenamiento de datos en un archivo de texto localizado en una tarjeta SD http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=144&in...
En el concepto anterior vimos como crear y leer un archivo de texto en la memoria interna del equipo Android. En
algunas situaciones podra ser til almacenar los datos en una tarjeta SD, esto debido a su mayor capacidad o la
facilidad de compartir los archivos con otras personas entregando la tarjeta SD.
Problema:
Confeccionar un programa que permita ingresar el nombre de un archivo y el contenido. Permitir grabar los datos
ingresados al presionar un botn. Disponer un segundo botn que permita recuperar los datos del archivo de texto.
Hacer que los archivos se graben en una tarjeta SD.
La interfaz visual a implementar es la siguiente:
El primer paso es modificar el archivo AndroidManifest.xml para permitir el acceso a la tarjeta SD desde nuestra
aplicacin esto lo hacemos desde el editor visual del archivo AndroidManifest.xml:
1 de 4 30/09/2013 10:01 a.m.

Debemos presionar el botn "Add" seleccionar "Uses Permision" y luego en name seleccionar
"android.permission.WRITE_EXTERNAL_STORAGE".
El cdigo fuente es:
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import android.os.Environment;

EditText et1;
EditText et2;
@Override
et1 = (EditText) findViewById(R.id.editText1);

}
@Override
return true;
}
2 de 4 30/09/2013 10:01 a.m.


String nomarchivo = et1.getText().toString();
String contenido = et2.getText().toString();
try {
File tarjeta = Environment.getExternalStorageDirectory();
File file = new File(tarjeta.getAbsolutePath(), nomarchivo);
OutputStreamWriter osw = new OutputStreamWriter(
new FileOutputStream(file));
osw.write(contenido);
osw.flush();
osw.close();
Toast.makeText(this, "Los datos fueron grabados correctamente",
Toast.LENGTH_SHORT).show();
et1.setText("");
et2.setText("");
} catch (IOException ioe) {
}
}
public void recuperar(View v) {

try {
FileInputStream fIn = new FileInputStream(file);
InputStreamReader archivo = new InputStreamReader(fIn);
BufferedReader br = new BufferedReader(archivo);
String linea = br.readLine();
String todo = "";
while (linea != null) {
todo = todo + linea + "
";
linea = br.readLine();
}
br.close();
archivo.close();
et2.setText(todo);
}
}
El mtodo para grabar los datos en un archivo de texto localizado en una tarjeta SD comienza obteniendo el directorio
raiz de la tarjeta a travs del mtodo getExternalStorageDirectory(), el mismo retorna un objeto de la clase File.

String contenido=et2.getText().toString();
try
{
Creamos un nuevo objeto de la clase File indicando el camino de la unidad SD y el nombre del archivo a crear:
Por ltimo similar al acceso de un archivo interno creamos un objeto de la clase OutputStreamWriter:
3 de 4 30/09/2013 10:01 a.m.

OutputStreamWriter osw =new OutputStreamWriter(new FileOutputStream(file));
Grabamos el contenido del EditText:
osw.write(contenido);
Cerramos el archivo:
osw.flush();
osw.close();
Toast.makeText(this,"Los datos fueron grabados correctamente",Toast.LENGTH_SHORT).show();
et1.setText("");
et2.setText("");
}
catch (IOException ioe)
{
}
}
Para la lectura del archivo nuevamente obtenemos la referencia de la tarjeta SD para obtener el path de la unidad de
almacenamiento, el resto del algoritmo es similar al visto con un archivo interno:
public void recuperar(View v) {

try {
FileInputStream fIn = new FileInputStream(file);
InputStreamReader archivo=new InputStreamReader(fIn);
BufferedReader br=new BufferedReader(archivo);
String linea=br.readLine();
String todo="";
while (linea!=null)
{
todo=todo+linea+"\n";
linea=br.readLine();
}
br.close();
archivo.close();
et2.setText(todo);
} catch (IOException e)
{
}
}
Retornar
4 de 4 30/09/2013 10:01 a.m.

Almacenamiento en una base de datos SQLite http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=145&in...
14 - Almacenamiento en una base de datos SQLite
Hemos visto hasta ahora dos modos de almacenar datos en forma permanente (archivos de texto y la clase
SharedPreferences), ahora veremos otra herramienta nativa de Android para almacenar datos en una base de datos
llamada SQLite.
SQLite es una base de datos Open Source, es muy popular en muchos dispositivos pequeos, como Android.
Las ventajas que presenta utilizar SQLite es que no requiere configuracin, no tiene un servidor de base de datos
ejecutndose en un proceso separado y es relativamente simple su empleo.
Problema:
Confeccionar un programa que permita almacenar los datos de votantes de una eleccin. Crear la tabla votantes y definir
los campos dni (documento de identidad), nombre del votante, colegio donde vota y nmero de mesa donde vota.
El programa debe permitir:
1 - Carga de personas.
2 - Consulta por el dni (para saber donde vota)
3 - Borrado de personas
4 - Modificacin de datos.
Primero implementamos una interfaz visual similar a esta:
Lo primero que haremos es crear una clase que herede de SQLiteOpenHelper. Esta clase nos permite crear la base de
datos y actualizar la estructura de tablas y datos iniciales.
Debemos implementar el constructor y sobreescribir los mtodos onCreate y onUpgrade.
El mtodo onCreate se le llama cuando la base de datos se crea por primera vez. Aqu es donde se define la estructura
1 de 6 30/09/2013 10:01 a.m.

de las tablas y se cargan eventualmente los datos iniciales
En el mtodo onUpgrade se llama cuando la base de datos debe ser actualizada. Tiene por objetivo eliminar tablas,
aadir tablas, o hacer cualquier otra cosa que necesita para actualizarse.
En nuestro problema implementaremos una nueva clase llamada AdminSQLiteOpenHelper que herede de la clase
SQLiteOpenHelper:
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteDatabase.CursorFactory;
import android.database.sqlite.SQLiteOpenHelper;
public class AdminSQLiteOpenHelper extends SQLiteOpenHelper {
public AdminSQLiteOpenHelper(Context context, String nombre, CursorFactory factory, i

super(context, nombre, factory, version);
}
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL("create table votantes(dni integer primary key, nombre text, colegio t
}
@Override
public void onUpgrade(SQLiteDatabase db, int versionAnte, int versionNue) {
db.execSQL("drop table if exists votantes");
db.execSQL("create table votantes(dni integer primary key, nombre text, colegio t
}
}
En el constructor solo llamamos al constructor de la clase padre pasando los datos que llegan en los parmetros:
public AdminSQLiteOpenHelper(Context context, String nombre, CursorFactory factory, int version) {

super(context, nombre, factory, version);
}
En el mtodo onCreate procedemos a crear la tabla votantes con los cuatro campos respectivos y definiendo el campo
dni como primary key:
public void onCreate(SQLiteDatabase db) {

db.execSQL("create table votantes(dni integer primary key, nombre text, colegio text, nromes
}
En el mtodo onUpgrade procedemos a borrar la tabla votantes y crear nuevamente la tabla (en este caso con la misma
estructura pero podra ser otra en un caso ms real:
public void onUpgrade(SQLiteDatabase db, int versionAnte, int versionNue) {

db.execSQL("drop table if exists votantes");
db.execSQL("create table votantes(dni integer primary key, nombre text, colegio text, nromes
}
Ahora veamos la otra clase que implementar las altas, bajas, modificaciones y consultas:
import android.content.ContentValues;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
2 de 6 30/09/2013 10:01 a.m.


private EditText et1, et2, et3, et4;
@Override

}
@Override
return true;
}
public void alta(View v) {

AdminSQLiteOpenHelper admin = new AdminSQLiteOpenHelper(this,
"administracion", null, 1);
SQLiteDatabase bd = admin.getWritableDatabase();
String dni = et1.getText().toString();
String nombre = et2.getText().toString();
String colegio = et3.getText().toString();
String nromesa = et4.getText().toString();
ContentValues registro = new ContentValues();
registro.put("dni", dni);
registro.put("nombre", nombre);
registro.put("colegio", colegio);
registro.put("nromesa", nromesa);
bd.insert("votantes", null, registro);
bd.close();
et1.setText("");
et2.setText("");
et3.setText("");
et4.setText("");
Toast.makeText(this, "Se cargaron los datos de la persona",
}
public void consulta(View v) {

Cursor fila = bd.rawQuery(
"select nombre,colegio,nromesa from votantes where dni=" + dni, null);
if (fila.moveToFirst()) {
et2.setText(fila.getString(0));
} else
Toast.makeText(this, "No existe una persona con dicho dni",
bd.close();
public void baja(View v) {

3 de 6 30/09/2013 10:01 a.m.

int cant = bd.delete("votantes", "dni=" + dni, null);

bd.close();
et1.setText("");
et2.setText("");
et3.setText("");
et4.setText("");
if (cant == 1)
Toast.makeText(this, "Se borr la persona con dicho documento",
else
Toast.makeText(this, "No existe una persona con dicho documento",
}
public void modificacion(View v) {

String nombre = et2.getText().toString();
String colegio = et3.getText().toString();
String nromesa = et4.getText().toString();
ContentValues registro = new ContentValues();
registro.put("nombre", nombre);
registro.put("colegio", colegio);
registro.put("nromesa", nromesa);
int cant = bd.update("votantes", registro, "dni=" + dni, null);
bd.close();
if (cant == 1)
Toast.makeText(this, "se modificaron los datos", Toast.LENGTH_SHORT)
.show();
else
Toast.makeText(this, "no existe una persona con dicho documento",
}
1 - Alta de datos.
Cuando se presiona el botn alta se ejecuta el mtodo "alta" recordemos inicializar la propiedad "OnClick" del botn
desde la ventana de visualizacin del archivo XML.
Lo primero que hacemos en este mtodo es crear un objeto de la clase que planteamos anteriormente y le pasamos al
constructor this (referencia del Activity actual), "administracion" (es el nombre de la base de datos que crearemos en el
caso que no exista) luego pasamos null y un uno indicando que es la primer versin de la base de datos (en caso que
cambiemos la estructura o agreguemos tablas por ejemplo podemos pasar un dos en lugar de un uno para que se
ejecute el mtodo onUpgrade donde indicamos la nuestra estructura de la base de datos)
Luego de crear un objeto de la clase AdminSqLiteOpenHelper procedemos a crear un objeto de la clase SQLiteDataBase
llamando al mtodo getWritableDatabase (la base de datos se abre en modo lectura y escritura).
Creamos un objeto de la clase ContentValues y mediante el mtodo put inicializamos todos tos campos a cargar.
Seguidamente llamamos al mtodo insert de la clase SQLiteDatabase pasando en el primer parmetro el nombre de la
tabla, como segundo parmetro un null y por ltimo el objeto de la clase ContentValues ya inicializado (este mtodo es el
que provoca que se inserte una nueva fila en la tabla votantes en la base de datos llamada administracion)
Borramos seguidamente los EditText y mostramos un mensaje para que conozca el operador que el alta de datos se
efectu en forma correcta:
public void alta(View v) {

AdminSQLiteOpenHelper admin=new AdminSQLiteOpenHelper(this, "administracion", null, 1);
SQLiteDatabase bd=admin.getWritableDatabase();
String dni=et1.getText().toString();
String nombre=et2.getText().toString();
String colegio=et3.getText().toString();
String nromesa=et4.getText().toString();
ContentValues registro=new ContentValues();
registro.put("dni",dni );
registro.put("nombre",nombre );
registro.put("colegio",colegio );
4 de 6 30/09/2013 10:01 a.m.

registro.put("nromesa",nromesa );
bd.insert("votantes", null, registro);
bd.close();
et1.setText("");
et2.setText("");
et3.setText("");
et4.setText("");
Toast.makeText(this, "Se cargaron los datos de la persona", Toast.LENGTH_SHORT).show();
}
2 - Consulta de datos.
Cuando se presiona el botn "Consulta por DNI" se ejecuta el mtodo consulta:
public void consulta(View v) {

Cursor fila=bd.rawQuery("select nombre,colegio,nromesa from votantes where dni="+dni+"",null);
if (fila.moveToFirst())
{
}
else
Toast.makeText(this, "No existe una persona con dicho dni", Toast.LENGTH_SHORT).show();
bd.close();
En el mtodo consulta lo primero que hacemos es crear un objeto de la clase AdminSQLiteOpenHelper y obtener una
referencia de la base de datos llamando al mtodo getWritableDatabase.
Seguidamente definimos una variable de la clase Cursor y la inicializamos con el valor devuelto por el mtodo llamado
rawQuery.
La clase Cursos almacena en este caso una fila o cero filas (una en caso que hayamos ingresado un dni existente en la
tabla votantes), llamamos al mtodo moveToFirst() de la clase Cursos y retorna true en caso de existir una persona con el
dni ingresado, en caso contrario retorna cero.
Para recuperar los datos propiamente dichos que queremos consultar llamamos al mtodo getString y le pasamos la
posicin del campo a recuperar (comienza a numerarse en cero, en este ejemplo la columna cero representa el campo
nombre, la columna 1 representa el campo colegio y la columna 2 representa el campo nromesa)
3 - Baja o borrado de datos.
Para borrar uno o ms registros la clase SQLiteDatabase tiene un mtodo que le pasamos en el primer parmetro el
nombre de la tabla y en el segundo la condicin que debe cumplirse para que se borre la fila de la tabla. El mtodo
delete retorna un entero que indica la cantidad de registros borrados:
public void baja(View v) {

int cant=bd.delete("votantes", "dni="+dni+"",null);
bd.close();
et1.setText("");
et2.setText("");
et3.setText("");
et4.setText("");
if (cant==1)
Toast.makeText(this, "Se borr la persona con dicho documento", Toast.LENGTH_SHORT).show();
else
Toast.makeText(this, "No existe una persona con dicho documento", Toast.LENGTH_SHORT).show();
}
4 - Modificacin de datos.
En la modificacin de datos debemos crear un objeto de la clase ContentValues y mediante el mtodo put almacenar los
valores para cada campo que ser modificado. Luego se llama al mtodo update de la clase SQLiteDatabase pasando el
nombre de la tabla, el objeto de la clase ContentValues y la condicin del where (el cuanto parmetro en este ejemplo no
se lo emplea)
public void modificacion(View v) {

5 de 6 30/09/2013 10:01 a.m.

String nombre=et2.getText().toString();
String colegio=et3.getText().toString();
String nromesa=et4.getText().toString();
ContentValues registro=new ContentValues();
registro.put("nombre",nombre);
registro.put("colegio",colegio);
registro.put("nromesa",nromesa);
int cant = bd.update("votantes", registro, "dni="+dni, null);
bd.close();
if (cant==1)
Toast.makeText(this, "se modificaron los datos", Toast.LENGTH_SHORT).show();
else
Toast.makeText(this, "no existe una persona con dicho documento", Toast.LENGTH_SHORT).show();
}
Retornar
6 de 6 30/09/2013 10:01 a.m.

Instalacin del programa Android en un dispositivo real http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=159&in...
Normalmente uno cuando desarrolla aplicaciones en Android hace toda la programacin, depuracin y pruebas en un
dispositivo virtual en la pc.
Ahora vamos a ver los pasos para probar la aplicacin en un dispositivo Android real.
La primera forma que veremos de probar nuestra aplicacin es copiar el archivo con extensin APK a nuestro dispositivo.
1. Primero en el cono de configuracin de nuestro telfono o tablet android seleccionamos la opcin "Aplicaciones" -> y
marcamos la opcin "Origen desconocido (Permitir la instalacin de aplicaciones no pertenecientes al mercado)"
2. Desde nuestro equipo de escritorio enviamos un mail a nuestro celular adjuntando el archivo con extensin apk que
se encuentra en el directorio bin de nuestro proyecto (por ejemplo adjuntemos el archivo proyecto015.apk)
3. Abramos el mail desde nuestro celular y seleccionemos el archivo adjunto. Confirmamos que queremos instalarlo.
Ya podemos probar nuestra aplicacin:
1 de 2 30/09/2013 10:02 a.m.

Instalacin del programa Android en un dispositivo real http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=159&in...
Retornar
2 de 2 30/09/2013 10:02 a.m.

Layout (LinearLayout) http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=146&in...
Android organiza las componentes visuales (Button, EditText, TextView etc.) en pantalla mediante contenedores llamados
Layout.
Hasta ahora no nos a preocupada como organizar una pantalla, sino nos hemos centrado en la funcionalidad de cada
programa que implementamos.
Ahora comenzaremos a preocuparnos como organizar y disponer las componentes dentro de la pantalla.
- LinearLayout.
LinearLayout es uno de los diseos ms simples y ms empleado. Simplemente establece los componentes visuales uno
junto al otro, ya sea horizontal o verticalmente.
Creemos un proyecto llamado ProyectoLayout1, borremos el TextView que agrega por defecto el ADT.
Para cambiar nuestro layout por defecto que es el RelativeLayout que crea el ADT debemos presionar el botn derecho
del mouse en la ventana Outline donde dice RelativeLayout y seleccionar Change Layout (Debemos seleccionar en el
dilogo que lo queremos cambiar por un layout de tipo LinearLayout vertical):
Una de las propiedades ms importantes del contenedor LinearLayout es Orientation.
Si fijamos la propiedad Orientation con el valor Vertical luego las componentes contenidas en el Layout se disponen una
1 de 12 30/09/2013 10:02 a.m.

debajo de otra (Cuando disponemos un contenedor LinearLayout con orientacin vertical y disponemos una serie de
botones luego podemos ver algo similar a:
En cambio si fijamos la propiedad Orientation con el valor Horizontal el resultado es la disposicin de las componentes
en forma horizontal:
2 de 12 30/09/2013 10:02 a.m.

Podemos disponer ms de una componente de tipo LinearLayout para implementar nuestra interfaz visual. Veamos los
objetos y propiedades a configurar si queremos la siguiente interfaz:
3 de 12 30/09/2013 10:02 a.m.

Para implementar este interfaz hemos agregado de la pestaa "Layouts" dos controles de tipo "LinearLayout (Vertical)"
en la parte superior y uno de tipo "LinearLayout (Horizontal)" en la parte inferior:
4 de 12 30/09/2013 10:02 a.m.

Disponemos un TextView y un EditText en el LinearLayout superior (Podemos arrastrarlos directamente a la ventana

Outline dentro del LinearLayout respectivo):
5 de 12 30/09/2013 10:02 a.m.

Ahora en el otro LinearLayout agregamos un Button y un TextView:
6 de 12 30/09/2013 10:02 a.m.

Para que el segundo LinearLayout quede en la parte inferior de la pantalla inicializamos las propiedades "Layout_weight"
con 1 para el superior y con 0 para el inferior:
7 de 12 30/09/2013 10:02 a.m.

Seleccionamos el EditText del primer LinearLayout y fijamos Layout Height con el valor Match Parent (para que ocupe
todo el espacio del contenedor) y para la propiedad gravity asignamos el valor top
8 de 12 30/09/2013 10:02 a.m.

Finalmente actualizamos el segundo EditText con lo que tenemos como resultado la interfaz:
9 de 12 30/09/2013 10:02 a.m.

Propiedad Gravity.
Otra propiedad muy utilizada es Gravity. Esta propiedad nos permite alinear a la izquierda, a la derecha, a la parte
superior, a la parte superior derecha etc.
Para implementar la siguiente interfaz:
10 de 12 30/09/2013 10:02 a.m.

Para el LinearLayout superior definimos la propiedad Layout_weight con valor 0 y el segundo LinearLayout la misma
propiedad Layout_weight con valor 1. Los dos botones que ubicamos en el segundo LinearLayout aparecen en la parte
inferior derecha ya que inicializamos la propiedad Gravity del segundo LinearLayout con los valores:
11 de 12 30/09/2013 10:02 a.m.

Retornar
12 de 12 30/09/2013 10:02 a.m.

Layout (TableLayout) http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=147&in...
El Layout de tipo TableLayout agrupa componentes en filas y columnas. Un TableLayout contiene un conjunto de
componentes de tipo TableRow que es el que agrupa componentes visuales por cada fila (cada fila puede tener distinta
cantidad de componentes visuales)
Cuando disponemos un control de Layouts de tipo TableLayout automticamente crea cuatro componentes de tipo
TableRow que los podemos ver en la ventana "Outline". Podemos borrar o agregar componentes de tipo TableRow segn
las necesidades de nuestro TableLayout:
Luego de borrar un control de tipo TableRow y agregar componentes de tipo Button la interfaz visual queda como sigue
(muchas veces es ms fcil agregar los controles visuales en la ventana Outline para disponerlos dentro de cada
tableRow):
1 de 3 30/09/2013 10:02 a.m.

Otra propiedad que nos puede ser til inicializar en los controles que se disponen dentro de un TableLayout es
layout_span. Esta propiedad permite que un control se expanda ms de una celda.
En el siguiente ejemplo el objeto de la clase Button de la segunda fila hemos dispuesto la propiedad layout_span con el
valor 2:
2 de 3 30/09/2013 10:02 a.m.

Si la propiedad no aparece en la ventana "Properties" cuando seleccionamos el objeto debemos entrar al archivo XML y
agregar manualmente dicha propiedad:
Retornar
3 de 3 30/09/2013 10:02 a.m.

Layout (RelativeLayout) http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=148&in...
El layout RelativeLayout es el que dispone el ADT por defecto cuando creamos un proyecto en Android. Hay varias
posibilidades cuando empleamos el RelativeLayout. Primero podemos alinear un control con respecto al Layout que lo
contiene. Para probarlo dispondremos un botn en cada vrtice y veremos que propiedades son afectadas e
inicializadas:
Como podemos ver cada control que agregamos se inicializan alguna de las propiedades:
alignParentLeft
alignParentRight
alignParentTop
alignParentBottom
centerHorizontal
centerVertical
centerInParent
Con este tipo de layout podemos disponer un control en forma relativa a otro control que haya dentro del RelativeLayout.
Veamos un ejemplo:
1 de 2 30/09/2013 10:02 a.m.

Layout (RelativeLayout) http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=148&in...
En este ejemplo hemos dispuesto el segundo botn debajo (below) del botn 1 y alineado a la izquierda (luego si
desplazamos el botn 1 se desplazar el botn 2)
La posicin relativa con respecto a otro control puede ser:
above (por encima)

below (debajo)
toLeftOf (a la izquierda de)
toRightOf (a la derecha)
Retornar
2 de 2 30/09/2013 10:02 a.m.

Layout (FrameLayout) http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=149&in...
El control de tipo FrameLayout dispone dentro del contenedor todos los controles visuales alineados al vrtice superior
izquierdo. Es decir si disponemos dos o ms controles los mismos se apilan.
Por ejemplo si disponemos dentro de un FrameLayout un ImageView y un Button luego el botn se superpone a la
imagen:
Otra aplicacin del control FrameLayout es disponer una serie de controles visuales no visibles e ir alternando cual se
hace visible.
Problema:
Disponer un ImageView y un Button dentro de un layout FrameLayout. Cuando se inicia la aplicacin mostrar solo el
botn y al ser presionado ocultar el botn y hacer visible la imagen que muestra el ImageView.
Creamos una interfaz visual similar a la siguiente:
1 de 4 30/09/2013 10:02 a.m.

Seleccionamos el control ImageView y fijarmos la propiedad Visibility con el valor invisible (esto hace que la imagen no se
muestre en pantalla)
Luego inicializamos la propiedad On click del control Button indicando el nombre del mtodo que se ejecutar al ser
presionado:
2 de 4 30/09/2013 10:02 a.m.

El cdigo fuente de la clase es:
import android.widget.Button;
import android.widget.ImageView;

Button b1;
ImageView iv1;
@Override
b1 = (Button) findViewById(R.id.button1);
iv1 = (ImageView) findViewById(R.id.imageView1);
}
@Override
3 de 4 30/09/2013 10:02 a.m.


return true;
}
public void ocultarBoton(View v) {

b1.setVisibility(View.INVISIBLE);
iv1.setVisibility(View.VISIBLE);
}
Cuando se presiona el botn procedemos a ocultar el botn y hacer visible la imagen:
public void ocultarBoton(View v) {

b1.setVisibility(View.INVISIBLE);
iv1.setVisibility(View.VISIBLE);
}
Retornar
4 de 4 30/09/2013 10:02 a.m.

Layout (ScrollView y LinearLayout) http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=150&in...
El ScrollView junto con un LinearLayout nos permite disponer una cantidad de componentes visuales que superan la
cantidad de espacio del visor del celular o tablet. Luego el usuario puede desplazar con el dedo la interfaz creada.
Problema:
Disponer un control de tipo ScrollView (que se encuentra en la pestaa Composite). Como veremos automticamente se
crea una componente de tipo LinearLayout y fijemos la propiedad Orientation del LinearLayout con el valor vertical:
Luego dispongamos numerosos botones que superen la cantidad de espacio del dispositivo. Numerar los botones con
los nmeros del 1 en adelante (recordar que podemos ir arrastrando los botones a la ventana Outline):
1 de 5 30/09/2013 10:03 a.m.

Luego si ejecutamos el programa veremos que podemos desplazar (scroll) todo el contenido del visor con el dedo:
2 de 5 30/09/2013 10:03 a.m.

Otra posibilidad para la implementacin de una interfaz en Android es disponer un LinearLayout en la parte superior y un
ScrollView en la parte inferior:
3 de 5 30/09/2013 10:03 a.m.

Esto hace que en tiempo de ejecucin quede fijo el LinearLayout y podamos desplazar con el dedo el ScrollView que
aparece en la parte inferior:
4 de 5 30/09/2013 10:03 a.m.

Retornar
5 de 5 30/09/2013 10:03 a.m.

Icono de la aplicacin http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=151&in...
Cuando creamos un proyecto para implementar una aplicacin con el plugin de Android nos crea un cono por defecto:
Los conos e imgenes se almacenan en la carpeta res (resources) y en esta hay cuatro carpetas llamadas:
drawable-ldpi
drawable-mdpi
drawable-hdpi
drawable-xhdpi
Y en cada una de estas hay un archivo llamado ic_launcher.png:
Como las resoluciones de los dispositivos Android pueden ser muy distintos (un celular, una tablet, un televisor etc.) se
recomienda proporcionar mltiples copias de cada imagen de recursos a diferentes resoluciones y almacenarlos en las
carpetas nombradas respetando las siguientes reglas:
res/drawable-ldpi/
75% del tamao de las imgenes almacenadas en la carpeta drawable-mdpi
El cono debe ser de 36*36 pxeles.
res/drawable-mdpi/
res/drawable-hdpi/
res/drawable-xhdpi/
Problema:
Crear una aplicacin, dibujar y almacenar tres archivos llamados icon.png. Tener en cuenta que el archivo que se
1 de 2 30/09/2013 10:04 a.m.

Icono de la aplicacin http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=151&in...
almacena en la carpeta drawable-mdpi debe ser de 48 pxeles, el de la carpeta drawable-mdpi de 36 pxeles y el de la

carpeta drawable-hdpi debe ser de 72 pxeles de ancho y alto. Ejecutar la aplicacin y ver el cono nuevo.
Retornar
2 de 2 30/09/2013 10:04 a.m.

Reproduccin de audio (archivo contenido en la aplicacin) http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=152&in...
Veremos los pasos para reproducir un archivo mp3 (otros formatos soportados por Android son: Ogg, Wav)
Problema:
Disponer dos botones con las etiquetas: Gato y Len, luego cuando se presione reproducir el archivo de audio
respectivo. Los archivos de sonidos almacenarlos en la misma aplicacin.
Luego de crear el proyecto procedemos a crear una carpeta llamada raw que dependa de la carpeta res, almacenamos
los dos archivos mp3 en dicha carpeta (para crear la carpeta presionamos el botn derecho del mouse sobre la carpeta
res y seleccionamos new -> folder):
Luego de copiar los archivos a la carpeta debemos refrescar los archivos contenidos en el proyecto presionando el botn
derecho del mouse y seleccionando la opcin "Refresh":
Podemos comprobar que los dos archivos estn referenciados en el proyecto.
1 de 3 30/09/2013 10:04 a.m.

Creamos una interfaz con dos botones e inicializamos las propiedades Text y On Click de cada botn:
El cdigo fuente de la clase Proyecto019Activity.java es:
import android.media.MediaPlayer;
@Override
}
@Override
return true;
2 de 3 30/09/2013 10:04 a.m.

public void presionGato(View v) {

MediaPlayer mp = MediaPlayer.create(this, R.raw.gato);
mp.start();
}
public void presionLeon(View v) {

MediaPlayer mp = MediaPlayer.create(this, R.raw.leon);
mp.start();
}
}
Cuando copiamos los archivos mp3 se genera luego en la clase R la referencia a los dos archivos y posteriormente los
podemos rescatar cuando creamos un objeto de la clase MediaPlayer:
MediaPlayer mp=MediaPlayer.create(this,R.raw.gato);
Seguidamente llamamos al mtodo start:
mp.start();
Retornar
3 de 3 30/09/2013 10:04 a.m.

Reproduccin, pausa, continuacin y detencin de un archivo de audio. http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=153&in...
Problema:
Confeccionar una aplicacin que permita Iniciar un archivo mp3, detener, continuar, detener en forma definitiva y
activacin o no de la reproduccin en forma circular.
Crear un archivo mp3 con el programa Audacity contando del 1 al 30.
Primero creamos un proyecto y definimos los 5 botones y mtodos a ejecutar cuando se presionen los botones
respectivos:
Creamos la carpeta raw y almacenamos en la misma el archivo mp3 creado previamente. Refrescamos la carpeta raw
para actualizar el archivo mp3:
1 de 4 30/09/2013 10:04 a.m.

El cdigo fuente es:

MediaPlayer mp;
Button b1;
int posicion = 0;
@Override
}
@Override
return true;
}
public void destruir() {

if (mp != null)
mp.release();
}
public void iniciar(View v) {

destruir();
2 de 4 30/09/2013 10:04 a.m.

mp = MediaPlayer.create(this, R.raw.numeros);
mp.start();
String op = b1.getText().toString();
if (op.equals("No reproducir en forma circular"))
mp.setLooping(false);
else
mp.setLooping(true);
}
public void pausar(View v) {

if (mp != null && mp.isPlaying()) {
posicion = mp.getCurrentPosition();
mp.pause();
}
}
public void continuar(View v) {

if (mp != null && mp.isPlaying() == false) {
mp.seekTo(posicion);
mp.start();
}
}
public void detener(View v) {

if (mp != null) {
mp.stop();
posicion = 0;
}
}
public void circular(View v) {

detener(null);
String op = b1.getText().toString();
b1.setText("reproducir en forma circular");
else
b1.setText("No reproducir en forma circular");
}
}
Primero definimos tres atributos uno de la clase MediaPlayer para administrar el archivo mp3, un entero donde se
almacena la posicin actual de reproduccin en milisegundos (para poder continuarla en el futuro) y la referencia de un
objeto de la clase Button:
MediaPlayer mp;
Button b1;
int posicion=0;
El mtodo destruir verifica con un if si el objeto de la clase MediaPlayer est creado procede a liberar recursos del mismo
llamando al mtodo release:
public void destruir() {

if(mp!=null)
mp.release();
}
El mtodo iniciar que se ejecuta al presionar el botn "Iniciar" primero llama al mtodo destruir (para el caso que el mp3
este en ejecucin actualmente) seguidamente creamos un objeto de la clase MediaPlayer llamando al mtodo create (en
3 de 4 30/09/2013 10:04 a.m.

este hacemos referencia al archivo que copiamos a la carpeta raw) Llamamos al mtodo start. Por ltimo extraemos el
texto del quinto botn y verificamos si la reproduccin debe ejecutarse en forma circular (en forma indefinida una y otra
vez):
public void iniciar(View v) {

destruir();
mp = MediaPlayer.create(this,R.raw.numeros);
mp.start();
String op=b1.getText().toString();
mp.setLooping(false);
else
mp.setLooping(true);
}
El mtodo pausar verifica que el objeto de la clase MediaPlayer este creado y en ejecucin, en caso afirmativo
recuperamos la posicin actual de reproduccin y llamamos seguidamente al mtodo pause:
public void pausar(View v) {

if(mp != null && mp.isPlaying()) {
posicion = mp.getCurrentPosition();
mp.pause();
}
}
El mtodo continuar verifica que el objeto de la clase MediaPlayer este creado y la propiedad isPlaying retorne false para
proceder a posicionar en que milisegundo continuar la reproduccin:
public void continuar(View v) {

if(mp != null && mp.isPlaying()==false) {
mp.seekTo(posicion);
mp.start();
}
}
El mtodo detener interrumpe la ejecucin del mp3 e inicializa el atributo posicion con cero:

if(mp != null) {
mp.stop();
posicion = 0;
}
}
Cuando se presiona el botn que cambia si la reproduccin se efecta en forma circular o no procedemos a extraer su
texto y segn dicho valor almacenamos el valor opuesto:
public void circular(View v) {

detener(null);
String op=b1.getText().toString();
b1.setText("reproducir en forma circular");
else
b1.setText("No reproducir en forma circular");
}
Retornar
4 de 4 30/09/2013 10:04 a.m.

Reproduccin de audio (archivo contenido en una tarjeta SD) http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=154&in...
El objetivo de este concepto es acceder a un archivo mp3 almacenado en la tarjeta SD de nuestro equipo.
Problema:
Disponer un botn con la etiqueta: "Gato", luego cuando se presione reproducir el archivo de audio respectivo. El archivo
de sonido almacenarlo en la tarjeta SD.
Luego de crear el proyecto debemos ejecutar la aplicacin en modo depuracin para poder acceder a la tarjeta SD que
crea el emulador Android. Para ejecutar la aplicacin en modo "Debug" presionamos el botn derecha del mouse sobre
el proyecto y seleccionamos la opcin "Debug A" "Android Aplication":
Una vez que se este ejecutando la aplicacin (no importa que todava no hemos implementado su funcionalidad)
procedemos a abrir la ventana "File Explorer" de Android. Seleccionamos del men de opciones de Eclipse: Window ->
Show View -> Other :
1 de 5 30/09/2013 10:05 a.m.

Y en esta ventana seleccionamos Android -> FileExplorer:
Ahora podemos ver la ventana donde administramos los archivos contenidos en la tarjeta SD que emula el "Android
Virtual Device":
2 de 5 30/09/2013 10:05 a.m.

En la carpeta sdcard debemos subir el archivo mp3 (debemos seleccionar esta carpeta con el mouse)
Esto lo hacemos mediante un botn que aparece en la parte derecha de esta ventana "Push a file onto device", luego de
esto tenemos el archivo montado en la tarjeta SD:
Ahora implementemos la interfaz de nuestra aplicacin (un solo botn) que cuando se presione llame al mtodo ejecutar:
3 de 5 30/09/2013 10:05 a.m.

El cdigo fuente es:
import android.net.Uri;
@Override
}
@Override
return true;
}

Uri datos = Uri.parse(Environment.getExternalStorageDirectory()
4 de 5 30/09/2013 10:05 a.m.

.getPath() + "/gato.mp3");
MediaPlayer mp = MediaPlayer.create(this, datos);
mp.start();
}
Creamos un objeto de la clase Uri llamando al mtodo parse donde indicamos el path y nombre del archivo a recuperar:
Uri datos = Uri.parse(Environment.getExternalStorageDirectory().getPath() +"/gato.mp3");
Creamos el objeto de la clase MediaPlayer pasando ahora la referencia del objeto de la clase Uri:
MediaPlayer mp=MediaPlayer.create(this, datos);
Iniciamos la reproduccin del mp3:
mp.start();
Recordar que para ejecutar este proyecto se debe subir un archivo mp3 llamado "gato.mp3" a la tarjeta SD.
Retornar
5 de 5 30/09/2013 10:05 a.m.

Reproduccin de audio (archivo localizado en internet) http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=155&in...
Ahora vamos a ver los pasos para reproducir un archivo almacenado en un servidor de internet.
Problema:
Disponer un botn con la etiqueta: "Gato", luego cuando se presione reproducir el archivo de audio respectivo. El archivo
de sonido se encuentra almacenado en http://www.codigofuenteya.com.ar/recursos/gato.mp3
El primer paso es modificar el archivo AndroidManifest.xml donde autorizamos a la aplicacin a acceder a recursos
localizados en internet:
Creamos la interfaz de la aplicacin e inicializamos el evento On click del Button con el mtodo que implementaremos:
1 de 4 30/09/2013 10:05 a.m.

El cdigo fuente es:
@Override
}
@Override
return true;
}

MediaPlayer mp = new MediaPlayer();
2 de 4 30/09/2013 10:05 a.m.

try {
mp.setDataSource("http://www.codigofuenteya.com.ar/recursos/gato.mp3");
mp.prepare();
mp.start();
}
}
Para recuperar un archivo mp3 de internet procedemos de la siguiente manera, primero creamos un objeto de la clase
MediaPlayer:
MediaPlayer mp=new MediaPlayer();
Luego llamamos al mtodo setDataSource indicando la direccin de internet donde se almacena el archivo mp3:
Llamamos al mtodo prepare y seguidamente llamamos a start:
mp.prepare();
mp.start();
Todo esto lo hacemos en un bloque try/catch para capturar excepciones de tipo IOException.
Esta primera aproximacin para ejecutar un mp3 localizado en internet bloquea la aplicacin hasta que se carga por
completo el archivo, es decir queda ejecutndose el mtodo mp.prepare() hasta que finaliza la recuperacin en forma
completa.
Problema:
Confeccionar otra aplicacin similar a la anterior pero que no se congele la interfaz de la aplicacin mientras se carga el
mp3. Mostrar un mensaje que el archivo se est cargando.
Desarrollamos un nuevo proyecto, asignamos el permiso de acceder a internet en el archivo AndroidManifest.xmp y

creamos una interfaz similar al problema anterior.
El cdigo fuente es:
import android.media.MediaPlayer.OnPreparedListener;
public class MainActivity extends Activity implements OnPreparedListener{

MediaPlayer mp;
@Override
3 de 4 30/09/2013 10:05 a.m.

}
@Override
return true;
}

mp = new MediaPlayer();
mp.setOnPreparedListener(this);
try {
mp.prepareAsync();
}
Toast t = Toast.makeText(this,
"Espere un momento mientras se carga el mp3",
Toast.LENGTH_SHORT);
t.show();
}
public void onPrepared(MediaPlayer mp) {

mp.start();
}
Para poder capturar el evento que el archivo se termin de recuperar debemos implementar la interface
OnPreparedListener:
public class Proyecto023Activity extends Activity implements OnPreparedListener {
Con esto decimos que nuestra clase implementar el mtodo onPrepared donde iniciamos la ejecucin del mp3:
public void onPrepared(MediaPlayer mp) {

mp.start();
}
En el evento click del botn creamos el objeto de la clase MediaPlayer, le pasamos al mtodo setOnPreparedListener la
direccin del objeto que capturar el evento de que el recurso est completo. Luego llamamos a los mtodos
setDataSource y prepareAsync para inicializar la carga del mp3. Finalmente mostramos un mensaje para informar al
usuario que el archivo se est descargando:

mp=new MediaPlayer();
mp.setOnPreparedListener(this);
try {
mp.prepareAsync();
}catch(IOException e) {
}
Toast t=Toast.makeText(this,"Espere un momento mientras se carga el mp3", Toast.LENGTH_SHORT
t.show();
}
Retornar
4 de 4 30/09/2013 10:05 a.m.

Reproduccin de audio utilizando el reproductor propio de Android (va I... http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=156&in...
Otra forma de ejecutar un archivo mp3 es mediante el reproductor interno de Android. Esta aplicacin reproduce todos
los formatos soportados por Android y tiene una interfaz que le ser familiar al usuario de nuestra aplicacin.
Problema:
Disponer un botn con la etiqueta: "Ejecutar mp3 con el reproductor propio de Android", luego cuando se presione
reproducir el archivo de audio respectivo con el reproductor de Android via Intent. El archivo de sonido almacenarlo en la
tarjeta SD.
Luego de crear el proyecto debemos ejecutar la aplicacin en modo depuracin para poder acceder a la tarjeta SD que
crea el emulador Android. Para ejecutar la aplicacin en modo "Debug" presionamos el botn derecha del mouse sobre
el proyecto y seleccionamos la opcin "Debug A" "Android Aplication":
Una vez que se este ejecutando la aplicacin (no importa que todava no hemos implementado su funcionalidad)
procedemos a abrir la ventana "File Explorer" de Android. Seleccionamos del men de opciones de Eclipse: Window ->
Show View -> Other :
1 de 5 30/09/2013 10:05 a.m.

Y en esta ventana seleccionamos Android -> FileExplorer:
Ahora podemos ver la ventana donde administramos los archivos contenidos en la tarjeta SD que emula el "Android
Virtual Device":
2 de 5 30/09/2013 10:05 a.m.

En la carpeta sdcard debemos subir el archivo mp3 (debemos seleccionar esta carpeta con el mouse)
Esto lo hacemos mediante un botn que aparece en la parte derecha de esta ventana "Push a file onto device", luego de
esto tenemos el archivo montado en la tarjeta SD:
Creamos la interfaz con el Button y especificamos el evento On click:
3 de 5 30/09/2013 10:05 a.m.

El cdigo fuente es:
@Override
}
@Override
return true;
}

Intent intent = new Intent(android.content.Intent.ACTION_VIEW);
Uri data = Uri.parse("file:///sdcard" + "/gato.mp3");
intent.setDataAndType(data, "audio/mp3");
4 de 5 30/09/2013 10:05 a.m.

startActivity(intent);
}
}
Creamos un objeto de la clase Intent y un objeto de la clase Uri referenciando al archivo mp3 almacenado en la tarjeta
SD. Indicamos mediante el mtodo setDataAndType el Uri y el tipo de archivo a reproducir. Activamos la aplicacin
mediante startActivity.
Retornar
5 de 5 30/09/2013 10:05 a.m.

Grabacin de audio mediante el grabador provisto por Android (via Intent) http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=157&in...
La forma ms sencilla de capturar audio en Android es mediante el grabador que provee el sistema operativo Android.
Invocamos la aplicacin de grabacin (tiene como ventana que la interfaz le es familiar al usuario, ya que muchas
aplicaciones utilizan esta caracterstica) y luego recuperamos el audio grabado.
Problema:
Disponer dos objetos de la clase Button con las etiquetas "Grabar" y "Reproducir". Cuando se presione el primer botn
proceder a activar la grabadora provista por Android. Cuando se presione el segundo botn reproducir el audio grabado.
Crear la interfaz e inicializar los eventos On click de cada botn:
El cdigo fuente es:
import android.provider.MediaStore;
1 de 3 30/09/2013 10:05 a.m.

int peticion = 1;
Uri url1;
@Override
}
@Override
return true;
}

Intent intent = new Intent(MediaStore.Audio.Media.RECORD_SOUND_ACTION);
startActivityForResult(intent, peticion);
}
public void reproducir(View v) {

MediaPlayer mediaPlayer = MediaPlayer.create(this, url1);
mediaPlayer.start();
}
protected void onActivityResult(int requestCode, int resultCode, Intent data) {

if (resultCode == RESULT_OK && requestCode == peticion) {
url1 = data.getData();
}
}
Cuando se presiona el botn de grabar el audio mediante un Intent activamos la aplicacin de grabacin propia de
Android.
Seguidamente llamamos al mtodo startActivityForResult para poder recuperar la grabacin luego de finalizada a travs
del mtodo onActivityResult:

Intent intent = new Intent(MediaStore.Audio.Media.RECORD_SOUND_ACTION);
startActivityForResult(intent, peticion);
}
Debemos pasar al mtodo startActivityForResult adems de la referencia del Intent una variable con un valor 0 o positivo
(luego este valor retornar al mtodo onActivityResult)
Cuando finalizamos la grabacin se ejecuta el mtodo onActivityResult, donde almacenamos en la variable url1 la
referencia al archivo de audio creado:
protected void onActivityResult (int requestCode, int resultCode, Intent data) {

if (resultCode == RESULT_OK && requestCode == peticion) {
url1 = data.getData();
}
}
Por ltimo para ejecutar el contenido de la grabacin utilizamos la clase ya vista MediaPlayer:

MediaPlayer mediaPlayer = MediaPlayer.create(this, url1);
mediaPlayer.start();
}
2 de 3 30/09/2013 10:05 a.m.

Retornar
3 de 3 30/09/2013 10:05 a.m.

Captura de audio mediante la clase MediaRecorder http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=158&in...
Otra forma de grabar audio en Android es el empleo de la clase MediaRecorder. Esta clase nos da ms libertades a la
hora de construir una aplicacin que requiere grabar audio.
Problema:
Disponer tres objetos de la clase Button con las etiquetas "Grabar", "Detener Grabacin" y "Reproducir Grabacin".
Disponer adems un TextView para informar del estado actual.
Cuando se presione el botn "Grabar" permitir registrar todos los sonidos hasta que se presione el botn "Detener
Grabacin". Cuando se presione el botn "Reproducir Grabacin" emitir el archivo de audio previamente generado.
La interfaz visual a implementar es la siguiente:
Tener en cuenta de no olvidar definir los tres mtodos para los tres botones: grabar, detener y reproducir.
Tambin debemos modificar el archivo AndroidManifest.xml donde debemos indicar que nuestra aplicacin acceder a la
grabadora de sonido y a la tarjeta SD donde se almacenar el archivo de sonido.
Esto lo hacemos seleccionando el archivo AndroidManifest.xml y en la pestaa Permissions registramos los dos
permisos:
1 de 6 30/09/2013 10:06 a.m.

El cdigo fuente es:
import java.io.File;
import android.media.MediaPlayer.OnCompletionListener;
import android.media.MediaRecorder;
public class MainActivity extends Activity implements OnCompletionListener {

TextView tv1;
MediaRecorder recorder;
MediaPlayer player;
File archivo;
Button b1, b2, b3;
@Override
tv1 = (TextView) this.findViewById(R.id.textView1);

}
@Override
return true;
}

recorder = new MediaRecorder();
recorder.setAudioSource(MediaRecorder.AudioSource.MIC);
recorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
2 de 6 30/09/2013 10:06 a.m.

recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
File path = new File(Environment.getExternalStorageDirectory()
.getPath());
try {
archivo = File.createTempFile("temporal", ".3gp", path);
}
recorder.setOutputFile(archivo.getAbsolutePath());
try {
recorder.prepare();
}
recorder.start();
tv1.setText("Grabando");
b1.setEnabled(false);
b2.setEnabled(true);
}

recorder.stop();
recorder.release();
player = new MediaPlayer();
player.setOnCompletionListener(this);
try {
player.setDataSource(archivo.getAbsolutePath());
}
try {
player.prepare();
}
tv1.setText("Listo para reproducir");
}

player.start();
tv1.setText("Reproduciendo");
}
public void onCompletion(MediaPlayer mp) {

tv1.setText("Listo");
}
}
Declaramos un objeto de la clase MediaRecorder para grabar audio:
MediaRecorder recorder;
Declaramos un objeto de la clase MediaPlayer para reproducir el archivo de sonido generado:
3 de 6 30/09/2013 10:06 a.m.

MediaPlayer player;
Declaramos un objeto de la clase File que hace referencia al archivo que se crear:
File archivo;
Declaramos las variables que harn referencia a los tres botones y al TextView:
TextView tv1;
Button b1,b2,b3;
En el mtodo onCreate obtenemos la referencia de los cuatro objetos creados en el archivo XML:
tv1 = (TextView) this.findViewById(R.id.tv1);

b1=(Button)findViewById(R.id.button1);
El mtodo ms importante de este concepto es el grabar:

File path = new File(Environment.getExternalStorageDirectory().getPath());
try {
}
try {
recorder.prepare();
}
recorder.start();
tv1.setText("Grabando");
}
Creamos un objeto de la clase MediaRecorder:
Seguidamente definimos el micrfono como fuente de audio:
Luego llamamos al mtodo setOutputFormat especificando que el archivo ser almacenado con la especificacin 3GPP y
con extensin .3gp
Especificamos el codec a emplear llamando al mtodo setAudioEncoder:
Obtenemos el path de la tarjeta SD y creamos un archivo temporal con extensin 3gp:
File path = new File(Environment.getExternalStorageDirectory().getPath());

try {
4 de 6 30/09/2013 10:06 a.m.

}
Con el mtodo setOutputFile de la clase MediaRecorder le indicamos el archivo donde debe almacenarse la grabacin:
Llamamos al mtodo prepare y finalmente al mtodo start para comenzar la grabacin:
try {
recorder.prepare();
}
recorder.start();
El mtodo detener:

recorder.stop();
recorder.release();
try {
}
try {
player.prepare();
}
tv1.setText("Listo para reproducir");
}
Llamamos primero al mtodo stop de la clase MediaRecorder y liberamos los recursos consumidos llamando a release:
recorder.stop();
recorder.release();
Creamos un objeto de la clase MediaPlayer para poder reproducir el archivo de audio que acabamos de grabar.
Indicamos mediante el mtodo setOnCompletionListener la referencia de la clase que ser informada cuando el audio
finalice:

Referenciamos el archivo a que debe reproducir:
try {
}
Finalmente llamamos al mtodo prepare de la clase MediaPlayer:
try {
player.prepare();
}
El mtodo reproducir simplemente llama al mtodo start de la clase MediaPlayer para iniciar la reproduccin del archivo
previamente grabado:
5 de 6 30/09/2013 10:06 a.m.


player.start();
tv1.setText("Reproduciendo");
}
El mtodo onCompletion se ejecuta cuando termina de reproducirse el archivo de audio:
public void onCompletion(MediaPlayer mp) {

tv1.setText("Listo");
}
Retornar
6 de 6 30/09/2013 10:06 a.m.

Men de opciones http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=160&in...
En Android la implementacin de un men de opciones permite mostrar opciones de una forma estandarizada entre
aplicaciones (esto hace que todos los programas tengan una vista de un men muy parecidos)
Los mens aparecen en la parte inferior de la pantalla cuando el usuario presiona el botn Men del celular.
La implementacin del men se puede hacer de forma similar a la interfaz visual de la aplicacin mediante la creacin de
un archivo XML y la construccin del mismo empleando las herramientas que provee el ADT.
Problema:
Confeccionar una aplicacin que muestre un men con dos opciones: una que visualice el "Acerca de..." (nombre de la
aplicacin, programador etc.) del programa y otra que finalice el programa.
El ADT ya creo el archivo XML para el activity principal y se encuentra localizado en la carpeta res/menu y se llama
activity_main.xml
La intefaz del editor de menu que nos provee el plugin de Android para Eclipse es:
Procedemos a insertar la primera opcin presionando el botn "Add", seguidamente seleccionamos "Item":
1 de 6 30/09/2013 10:06 a.m.

Luego nos queda inicializar como mnimo el ttulo de que mostrar dicha opcin:
Ahora nuevamente presionamos el botn "Add" para aadir la segunda opcin. En el dilogo que aparece seleccionamos
"Create a new element at the top level, in Menu", seguidamente seleccionamos "Item" y confirmamos:
2 de 6 30/09/2013 10:06 a.m.

Configuramos la propiedad Title de la segunda opcin:
3 de 6 30/09/2013 10:06 a.m.

Paso seguido debemos sobreescribir los mtodos onCreateOptionsMenu (que ya lo tenemos codificado en el archivo
Java) y onOptionsItemSelected heredados de la clase Activity.
import android.view.MenuItem;
@Override
}
@Override
return true;
4 de 6 30/09/2013 10:06 a.m.

@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case R.id.item1:
Toast.makeText(this, "Programador: Diego (23/08/2011)",
break;
case R.id.item2:
finish();
}
return true;
}
En el mtodo onCreateOptionsMenu creamos un objeto de la clase MenuInflater y mediante el mtodo inflate vinculamos
el identificador del archivo de recursos: R.menu.activity_main y el objeto de la clase menu que llega como parmetro.
Debemos retornar true:
@Override
return true;
}
En el mtodo onOptionsItemSelected debemos disponer un switch para identificar cual de las opciones del men fue
seleccionado. El parmetro item de la clase MenuItem tiene la referencia del objeto que fue pulsado. Luego obtenemos
su Id llamando al mtodo getItemId y a travs del switch verificamos con el recurso que coincide y procedemos a efectuar
la actividad respectiva (si se selecciona la primer opcin mostramos un mensaje mediante la clase Toast, si se seleccion
la segunda opcin llamamos al mtodo finish para finalizar el programa:
@Override
case R.id.item1:
Toast.makeText(this, "Programador: Diego (23/08/2011)",
break;
case R.id.item2:
finish();
}
return true;
}
Desde el emulador para activar el men debemos presionar el siguiente botn:
5 de 6 30/09/2013 10:06 a.m.

Retornar
6 de 6 30/09/2013 10:06 a.m.

Men de opciones con submen http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=161&in...
Ahora veremos que podemos desplegar un submen cuando se selecciona una opcin del men principal.
Problema:
Confeccionar una aplicacin que muestre un men con dos opciones: una que visualice el texto "Sitios interesantes..." y
al ser seleccionado muestre otro submen con una serie de buscadores. y otra opcin en el men principal para que
finalice el programa.
Modificaremos el archivo activity_main.xml de la carpeta res/menu. Podemos eliminar el item que crea por defecto el ADT
(menu_settings(Item)
Primero insertamos un item que mostrar el mensaje "Sitios interesantes..." para esto presionamos el botn "Add" y
seleccionamos "Item" en Title disponemos "Sitios interesantes..."
Presionamos "Add" y seleccionamos "Sub-Menu":
1 de 6 30/09/2013 10:06 a.m.

Luego aadimos varios Menu Item al Sub-Menu (uno por cada sitio web a enlazar):
2 de 6 30/09/2013 10:06 a.m.

La estructura final del men de opciones debe ser la siguiente:
3 de 6 30/09/2013 10:06 a.m.

@Override
}
@Override
return true;
}
4 de 6 30/09/2013 10:06 a.m.

@Override
Intent i;
case R.id.item2:
i = new Intent("android.intent.action.VIEW",
Uri.parse("http://www.google.com"));
startActivity(i);
break;
case R.id.item3:
Uri.parse("http://www.yahoo.com"));
startActivity(i);
break;
case R.id.item4:
Uri.parse("http://www.bing.com"));
startActivity(i);
break;
case R.id.item5:
finish();
}
return true;
}
El mtodo onCreateOptionsMenu es idntico al concepto anterior. En el mtodo onOptionsItemSelected verificamos cual

de los MenuItem es seleccionado y procedemos a invocar mediante un Intent al navegador configurado por defecto para
el dispositivo.
La visualizacin del submen en tiempo de ejecucin es similar a:
5 de 6 30/09/2013 10:06 a.m.

Retornar
6 de 6 30/09/2013 10:06 a.m.

Men de opciones con conos en los MenuItem http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=162&in...
Otra posibilidad es disponer grficos dentro de los MenuItem de nuestro programa.
Problema:
Confeccionar una aplicacin que muestre un men con dos opciones: una que active el navegador con YouTube y otra
que active Facebook. Disponer un cono para cada MenuItem.
Luego de crear el proyecto procedemos a buscar dos conos representativos de Youtube y Facebook (dos archivos png
de 48 pxeles de ancho y alto) y los almacenamos en la carpeta drawable-mdpi.
Luego de refrescar la carpeta debemos tener en nuestro proyecto en dicha carpeta tres archivos:
Ahora tenemos que crear los dos Item y especificar las propiedades Title (con el texto que queremos que se muestre) y la
propiedad Icon.
Para configurar cada icon procedemos a asignar los valores @drawable/youtube y @drawable/facebook (los nombres
coinciden con los nombres de archivos que copiamos a la carpeta drawable)
Nos queda agregar solo la funcionalidad de cada MenuItem:
@Override
}
@Override
1 de 3 30/09/2013 10:12 a.m.


return true;
}
@Override
Intent i;
case R.id.item1:
Uri.parse("http://www.youtube.com"));
startActivity(i);
break;
case R.id.item2:
Uri.parse("http://www.facebook.com"));
startActivity(i);
}
return true;
}
}
Luego cuando lo ejecutamos podemos observar el cono que se muestra en cada MenuItem:
2 de 3 30/09/2013 10:12 a.m.

Retornar
3 de 3 30/09/2013 10:12 a.m.

Men contextuales http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=163&in...
Otra variante de men de opciones son los men contextuales que se pueden asociar a distintos componentes visuales
del formulario (TextView, EditText, ListView etc.)
Un men contectual aparece cuando el usuario presiona por un tiempo ms o menos prolongado el control visual.
Problema:
Confeccionar una aplicacin que muestre un EditText y asociarle un men contextual que permita cambiar el color de
fondo del mismo. El men debe permitir seleccionar entre el rojo, verde y azul.
Primero creamos un proyecto y creamos una interfaz con un control de tipo EditText:
Luego creamos el archivo XML que contendr el men de opciones (presionamos el botn derecho del mouse sobre la
carpeta res de nuestro proyecto y seleccionamos New -> Android XML File):
1 de 4 30/09/2013 10:12 a.m.

Aparece un dilogo donde debemos indicar el nombre del archivo de recursos a crear (lo llamamos menu1, este es el
nombre del archivo XML que se crear en una carpeta llamada menu que depende de la carpeta res) y seleccionamos el
RadioButton de menu
Ya tenemos una nueva carpeta llamada menu y un archivo llamado menu1.
Creamos las tres opciones del men:
2 de 4 30/09/2013 10:12 a.m.

Ahora veamos como asociar el archivo XML donde definimos el men con el cdigo Java:
package androidya.proyecto030;
import android.graphics.Color;
import android.view.ContextMenu;
import android.view.ContextMenu.ContextMenuInfo;
import android.view.MenuInflater;
public class Proyecto030Activity extends Activity {

EditText et1;
/** Called when the activity is first created. */
@Override
et1=(EditText)findViewById(R.id.editText1);
registerForContextMenu(et1);
}
3 de 4 30/09/2013 10:12 a.m.

@Override
public void onCreateContextMenu(ContextMenu menu, View v,ContextMenuInfo menuIn
{
menu.setHeaderTitle("Elija el color de fondo:");
MenuInflater inflater = getMenuInflater();
inflater.inflate(R.menu.menu1, menu);
}
@Override
public boolean onContextItemSelected(MenuItem item) {
case R.id.item1:et1.setBackgroundColor(Color.rgb(255, 0, 0)) ;
break;
break;
break;
}
return true;
}
}
En el mtodo onCreateContextMenu asociamos el archivo XML llamando al mtodo inflate de la clase MenuInflate.
Podemos tambin llamar al mtodo setHeaderTitle para mostrar un ttulo en el men emergente.
@Override
public void onCreateContextMenu(ContextMenu menu, View v,ContextMenuInfo menuInfo)
{
menu.setHeaderTitle("Elija el color de fondo:");
MenuInflater inflater = getMenuInflater();
inflater.inflate(R.menu.menu1, menu);
}
Para la captura de eventos de los MenuItem debemos implementar el mtodo onContextItemSelected donde mediante un
switch verificamos cual de los MenuItem fue seleccionado y cambiamos el color de fondo del control EditText:
@Override
public boolean onContextItemSelected(MenuItem item) {
break;
break;
break;
}
return true;
}
Retornar
4 de 4 30/09/2013 10:12 a.m.

AlertDialog simple http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=164&in...
El dilogo ms simple que podemos crear con Android en una ventana con un ttulo, un mensaje y un botn para
cerrarlo.
Muy til si tenemos que informar al usuario y no queremos que la ventana desaparezca hasta que el usuario presione un
botn para ocultar el dilogo.
Problema:
Confeccionar una aplicacin que muestre un dilogo cada vez que se inicie la aplicacin informando que el programa
que est ejecutando es un programa de prueba y no el completo.
Primero creamos un proyecto llamado: proyecto031

Lo almacenamos en el paquete: androidya.proyecto031
El cdigo fuente de la aplicacin queda como sigue:
import android.app.AlertDialog;

@Override
AlertDialog.Builder builder = new AlertDialog.Builder(this);

builder.setTitle("Importante");
builder.setMessage("Este es un programa solo de prueba y no la versin comp
builder.setPositiveButton("OK",null);
builder.create();
builder.show();
}
}
Como queremos que el dilogo aparezca inmediatamente se arranque la aplicacin procedemos a incorporar el cdigo
en el mtodo onCreate.
Primero debemos importar la clase AlertDialog:
La clase AlertDialog contiene otra clase llamada Builder que es la que encapsula la creacin de objetos de la clase
AlertDialog. Procedemos a definir y crear un objeto de la clase Builder contenida en la clase AlertDialog:
AlertDialog.Builder builder = new AlertDialog.Builder(this);
Una vez creado el objeto procedemos a llamar al mtodo que define el ttulo a mostrar en el dilogo:
builder.setTitle("Importante");
1 de 2 30/09/2013 10:12 a.m.

AlertDialog simple http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=164&in...
El mensaje propiamente dicho lo configuramos llamando al mtodo setMessage:
builder.setMessage("Este es un programa solo de prueba y no la versin completa");
Mostramos un botn para poder cerrar el dilogo:
builder.setPositiveButton("OK",null);
Finalmente llamamos al mtodo que crea el dilogo y el que lo visualiza:
builder.create();
builder.show();
La interfaz visual del dilogo en tiempo de ejecucin es:
Retornar
2 de 2 30/09/2013 10:12 a.m.

AlertDialog con botones de confirmar y cancelar http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=165&in...
Problema:
Confeccionar una aplicacin que muestre un dilogo cada vez que se inicie la aplicacin informando: "Acepta la
ejecucin de este programa en modo prueba?" y dos botones para confirmar o rechazar. En caso que se rechace
finalizar la ejecucin del programa.

import android.content.DialogInterface;

@Override
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(
cancelar();
}
});
dialogo1.show();
}
public void aceptar() {

Toast t=Toast.makeText(this,"Bienvenido a probar el programa.", Toast.LENGT
t.show();
}
public void cancelar() {

finish();
}
}
1 de 3 30/09/2013 10:13 a.m.

Creamos un objeto de la clase AlertDialog a travs de la clase Builder:
AlertDialog.Builder dialogo1 = new AlertDialog.Builder(this);
Configuramos el ttulo del dilogo:
dialogo1.setTitle("Importante");
Configuramos el mensaje del dilogo:
dialogo1.setMessage(" Acepta la ejecucin de este programa en modo prueba ?");
Evitamos que el dilogo sea salteado por cualquier medio distinto a presionar alguno de los dos botones:
dialogo1.setCancelable(false);
Llamamos al mtodo setPositiveButton indicando el texto a mostrar en el botn y la clase annima que capturar el
evento clic del botn:
dialogo1.setPositiveButton("Confirmar", new DialogInterface.OnClickListener() {

aceptar();
}
});
De forma similar procedemos con el botn de cancelar:
dialogo1.setNegativeButton("Cancelar", new DialogInterface.OnClickListener() {

cancelar();
}
});
Mostramos el dilogo:
dialogo1.show();
Definimos los mtodos del Activity que se llamaran desde las clases annimas:
public void aceptar() {

Toast t=Toast.makeText(this,"Bienvenido a probar el programa.", Toast.LENGTH_SHORT);
t.show();
}
public void cancelar() {

finish();
}
La interfaz del dilogo es similar a esta:
2 de 3 30/09/2013 10:13 a.m.

Retornar
3 de 3 30/09/2013 10:13 a.m.

Notificaciones o mensajes mediante la clase Toast http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=166&in...
La clase Toast nos permite mostrar un mensaje superpuesto a la ventana por un perodo de tiempo pero sin congelar la
aplicacin. Este mensaje no permite interactuar con el usuario (no se pueden ingresar datos, seleccionar botones ni
obligar a que se cierre)
Eventualmente se lo puede localizar en distintas partes del dispositivo.
Problema:
Confeccionar una aplicacin que muestre una serie de botones y active mensajes de notificaciones con la clase Toast.

La interfaz visual a implementar son tres botones:
No olvidemos inicializar la propiedad On Click de cada botn con los mtodos: prueba1, prueba2 y prueba3.
import android.view.Gravity;
import android.view.LayoutInflater;
1 de 6 30/09/2013 10:13 a.m.


@Override
}
public void prueba1(View v) {

Toast toast = Toast.makeText(this, "Mensaje 1", Toast.LENGTH_SHORT);
toast.show();
}

toast.setGravity(Gravity.CENTER_VERTICAL, 0, 0);
toast.show();
}

LayoutInflater inflater = getLayoutInflater();
View layout = inflater.inflate(R.layout.toast1, null);
Toast toast = new Toast(getApplicationContext());
toast.setDuration(Toast.LENGTH_LONG);
toast.setView(layout);
toast.show();
}
}
Para el evento click del primer botn mostramos el mensaje con las estructura ms simple que nos provee la clase Toast.
Definimos un objeto de la clase Toast y llamamos al mtodo makeText pasando como parmetro la referencia del Activity,
el mensaje a mostrar y una constante indicando si queremos que el mensaje aparezca por un perodo corto o largo de
tiempo en la pantalla. Por ltimo llamamos al mtodo show para que se muestre el mensaje:

toast.show();
}
2 de 6 30/09/2013 10:13 a.m.

Si queremos ubicar en otra parte de la pantalla debemos llamar al mtodo setGravity e indicar en el primer parmetro
una constante (en este ejemplo lo centramos verticalmente)
En el segundo y tercer parmetro de setGravity podemos desplazarlo una cantidad de pxeles hacia derecha o izquierda,
arriba o abajo segn indiquemos valores positivos o negativos.
Luego el mtodo completo para este segundo Toast es:

toast.show();
}
3 de 6 30/09/2013 10:13 a.m.

Para generar un Toast customizado debemos crear un archivo XML donde creamos visualmente los controles a mostrar,
en este ejemplo creamos el siguiente archivo (crear un archivo llamado toast1.xml):
4 de 6 30/09/2013 10:13 a.m.

Este recurso luego lo incorporamos en el Toast mediante el siguiente cdigo:

LayoutInflater inflater = getLayoutInflater();
View layout = inflater.inflate(R.layout.toast1,null);
Toast toast = new Toast(getApplicationContext());
toast.setDuration(Toast.LENGTH_LONG);
toast.show();
}
Mediante la clase LayoutInflate procedemos a leer el contenido del archivo XML creado anteriormente y lo enlazamos con
el toast mediante el mtodo:
En pantalla luego el Toast customizado aparece de la siguiente forma:
5 de 6 30/09/2013 10:13 a.m.

Retornar
6 de 6 30/09/2013 10:13 a.m.

Dibujar: graficar un pxel http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=167&in...
Problema:
Graficar un pxel de color negro en medio de la pantalla del dispositivo.
Para poder hacer esta simple tarea debemos seguir una serie de pasos:
1 - Creamos un proyecto llamado: proyecto034

Lo almacenamos en el paquete: com.androidya.proyecto034
Borramos el TextView que agrega automticamente el plug-in de Eclipse y a definir un id para el RelativeLayout (le
asignamos como Id el valor @+Id/layout1) y grabamos las modificaciones:
Ahora codificamos la clase donde se encuentra toda la lgica para encender el pxel:
import android.graphics.Canvas;
import android.graphics.Paint;
1 de 4 30/09/2013 10:13 a.m.

import android.widget.RelativeLayout;
@Override
RelativeLayout layout1 = (RelativeLayout) findViewById(R.id.layout1);

Lienzo fondo = new Lienzo(this);
layout1.addView(fondo);
}
@Override
return true;
}
class Lienzo extends View {
public Lienzo(Context context) {

super(context);
}
protected void onDraw(Canvas canvas) {

int ancho = canvas.getWidth();
int alto = canvas.getHeight();
Paint pincel1 = new Paint();
pincel1.setARGB(255, 0, 0, 0);
canvas.drawPoint(ancho / 2, alto / 2, pincel1);
}
}
Debemos crear una clase que herede de la clase View (todos los controles visuales en Android heredan de esta clase) y
sobreescribir el mtodo onDraw. El mtodo onDraw se ejecuta cuando tiene que graficarse. Para acceder a las primitivas
grficas hay una clase llamada Canvas que encapsula todo lo relacionado a pintar pxeles, lneas, rectngules etc.:

int ancho=canvas.getWidth();
int alto=canvas.getHeight();
Paint pincel1=new Paint();
pincel1.setARGB(255,0,0,0);
canvas.drawPoint(ancho/2, alto/2, pincel1);
}
Lo primero que hacemos en el mtodo onDraw es obtener el ancho y alto en pxeles del dispositivo mediante los mtodos
getWidth() y getHeight() que nos provee la clase Canvas. Seguidamente creamos un objeto de la clase Paint. Llamamos
al mtodo setARGB para definir el color del pincel (el primer parmetro indica el valor de transparencia con 255
indicamos que no hay transparencia, luego indicamos la cantidad de rojo, verde y azul.
Por ltimo debemos llamar al mtodo drawPoint que dibuja el pxel en la columna, fila y pincel que le pasamos como
parmetros.
Como podemos observar la clase Lienzo hereda de View e implementa el constructor donde llegar la referencia del
Activity donde se inserta:
2 de 4 30/09/2013 10:13 a.m.


super(context);
}

canvas.drawPoint(ancho/2, alto/2, pincel1);
}
}
Por ltimo en el mtodo onCreate del Activity obtenemos la referencia del RelativeLayout que tiene el Activity. Creamos
un objeto de la clase Lienzo (llamado fondo) y agregamos el objeto fondo al RelativeLayout llamando al mtodo addView:


}
Cuando ejecutemos el programa veremos un pxel en medio de la pantalla de color negro:
3 de 4 30/09/2013 10:13 a.m.

Retornar
4 de 4 30/09/2013 10:13 a.m.

Dibujar: pintar fondo y dibujar lneas http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=168&in...
Problema:
Pintar el fondo de color amarillo y dibujar una serie de lneas con distintos estilos.

Borramos el TextView que agrega automticamente el plug-in de Eclipse y difinimos el id del RelativeLayout con el valor:
@+id/layout1:
Ahora codificamos la clase donde se encuentra toda la lgica para pintar el fondo y dibujar las lneas:
1 de 4 30/09/2013 10:13 a.m.

@Override

}
@Override
return true;
}

super(context);
}

canvas.drawRGB(255, 255, 0);
canvas.drawLine(0, 30, ancho, 30, pincel1);
pincel1.setStrokeWidth(4);
}
}
Veamos el mtodo onDraw donde pintamos el fondo de la componente llamando al mtodo drawRGB donde indicamos
la cantidad de rojo, verde a azul:

canvas.drawRGB(255,255,0);
Creamos un objeto de la clase paint y definimos el color rojo (recordemos que el primer parmetro indica el valor de la
transparencia, si vale 255 es totalmente opaco, con un valor menor el trazo de la lnea tendr transparencia.
El mtodo para graficar una lnea se llama drawLine y tiene como parmetros la columna y fila del punto inicial y el tercer
y cuarto parmetro indica la columna y fila del punto final de la lnea (en este ejemplo se dibujar una lnea horizontal en
la fila 30 y tendr un ancho que coincide con el ancho del dispositivo), el ltimo parmetro es el objeto de la clase Paint
que indica el color de la lnea:

La siguiente lnea la dibujamos en la fila 60 pero previamente cambiamos el grosor del pincel llamando al mtodo
setTrokeWidth indicando que sern 4 pxeles el grosor:
2 de 4 30/09/2013 10:13 a.m.

La vista previa en el dispositivo ser:
Problema propuesto
1. Confeccionar una aplicacin que muestre una hoja en la pantalla similar a esta:
3 de 4 30/09/2013 10:13 a.m.

Retornar
4 de 4 30/09/2013 10:13 a.m.

Dibujar: rectngulos http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=169&in...
Problema:
Pintar el fondo de color blanco y dibujar una serie de rectngulos con distintos estilos.

@+id/layout1:
Ahora codificamos la clase donde se encuentra toda la lgica:
import android.graphics.Paint.Style;
1 de 4 30/09/2013 10:14 a.m.

@Override

}
@Override
return true;
}

super(context);
}

canvas.drawRect(10,10,ancho-10,40,pincel1);
pincel1.setStyle(Style.STROKE);
}
}
En el mtodo onDraw de la clase Lienzo procedemos a pintar el fondo de color blanco:
Obtenemos el ancho del dispositivo:
Creamos un objeto de la clase Paint:
Activamos el color rojo:
2 de 4 30/09/2013 10:14 a.m.

Dibujamos un rectngulo desde la coordenada columna:10 y fila 10 hasta la columna que coincide con el ancho de la
pantalla menos 10 pxeles y la fila 40. Adems le pasamos el pincel a utilizar:
Para el siguiente rectngulo configuramos el pincel para que solo pinte el permetro llamando al mtodo setStyle y
pasando la constante STROKE:
Por ltimo dibujamos otro rectngulo que solo se pinta el permetro pero cambiamos el grosor del lapiz llamando al
mtodo setStrokeWidth:
La vista previa de la aplicacin es:
3 de 4 30/09/2013 10:14 a.m.

Retornar
4 de 4 30/09/2013 10:14 a.m.

Dibujar: crculos http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=170&in...
Problema:
Pintar el fondo de color blanco y dibujar 10 crculos crecientes desde el medio de la pantalla.

@+id/layout1:
1 de 3 30/09/2013 10:14 a.m.

@Override

}
@Override
return true;
}

super(context);
}

for (int f = 0; f < 10; f++) {
canvas.drawCircle(ancho / 2, alto / 2, f * 15, pincel1);
}
}
}
Pintamos el fondo de blanco y obtenemos el ancho y alto del control:

Creamos un objeto de la clase Paint, fijamos el color rojo y mediante setStyle indicamos que solo se debe pintar el
permetro:

Disponemos un for para dibujar los 10 crculos concntricos (indicamos en los dos primeros parmetros el punto central
del crculo y en el tercer parmetro el radio del crculo:
for(int f=0;f<10;f++) {
2 de 3 30/09/2013 10:14 a.m.

canvas.drawCircle(ancho/2, alto/2, f*15, pincel1);

}
}
Retornar
3 de 3 30/09/2013 10:14 a.m.

Dibujar: valos http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=171&in...
Problema:
Dibujar un valo que ocupe toda la pantalla y un crculo en su interior.

@+id/layout1:
import android.graphics.RectF;
1 de 4 30/09/2013 10:14 a.m.

import android.view.Window;
import android.view.WindowManager;
@Override
requestWindowFeature(Window.FEATURE_NO_TITLE);
getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
WindowManager.LayoutParams.FLAG_FULLSCREEN);

}
@Override
return true;
}

super(context);
}


RectF rectangulo1 = new RectF(0, 0, ancho, alto);
canvas.drawOval(rectangulo1, pincel1);
int menor;
if (ancho < alto)
menor = ancho;
else
menor = alto;
pincel1.setStyle(Style.FILL);
pincel1.setARGB(255, 255, 255, 0);
canvas.drawCircle(ancho / 2, alto / 2, menor / 2, pincel1);
}
}
2 de 4 30/09/2013 10:14 a.m.

Para ocultar la barra del ttulo y la barra superior debemos hacer lo siguiente en el mtodo onCreate:
@Override

}
En el mtodo onDraw pintamos el fondo de blanco y obtenemos el ancho y alto de la pantalla:

Seguidamente creamos el objeto de la clase Paint y configuramos el color, grosor de lnea y estilo:

Creamos un objeto de la clase RectT pasando como dato la coordenada superior izquierda del valo y la coordenada
inferior derecha del mismo (teniendo en cuenta que el valo se dibujar en ese rectngulo imaginario que indicamos con
dichas coordenadas):
RectF rectangulo1=new RectF(0,0,ancho,alto);

canvas.drawOval(rectangulo1, pincel1);
Obtenemos el valor menor del ancho y alto del dispositivo:
int menor;
if (ancho<alto)
menor=ancho;
else
menor=alto;
Configuramos ahora el pincel para dibujar el crculo y lo dibujamos:
pincel1.setStyle(Style.FILL);
pincel1.setARGB(255, 255, 255, 0);
canvas.drawCircle(ancho/2, alto/2, menor/2, pincel1);
}
3 de 4 30/09/2013 10:14 a.m.

Retornar
4 de 4 30/09/2013 10:14 a.m.

Dibujar: texto http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=172&in...
Otra recurso que nos permite la clase Canvas es el de graficar texto.

@+id/layout1:
import android.graphics.Typeface;
1 de 3 30/09/2013 10:07 a.m.

@Override

}
@Override
return true;
}

super(context);
}

pincel1.setTextSize(30);
pincel1.setTypeface(Typeface.SERIF);
canvas.drawText("Hola Mundo (SERIF)", 0, 70, pincel1);
pincel1.setTypeface(Typeface.SANS_SERIF);
canvas.drawText("Hola Mundo (SANS SERIF)", 0, 100, pincel1);
pincel1.setTypeface(Typeface.MONOSPACE);
canvas.drawText("Hola Mundo (MONOSPACE)", 0, 140, pincel1);
Typeface tf = Typeface.create(Typeface.SERIF, Typeface.ITALIC);
pincel1.setTypeface(tf);
canvas.drawText("Hola Mundo (SERIF ITALIC)", 0, 180, pincel1);
tf = Typeface.create(Typeface.SERIF, Typeface.ITALIC
| Typeface.BOLD);
pincel1.setTypeface(tf);
canvas.drawText("Hola Mundo (SERIF ITALIC BOLD)", 0, 220, pincel1);
}
}
}
Para graficar texto disponemos del mtodo drawText que nos permite imprimir un String en una determinada columna,
fila con un determinado pincel que podemos definir su color:

El tamao de la letra:
2 de 3 30/09/2013 10:07 a.m.

El estilo de la letra:
pincel1.setTypeface(Typeface.SERIF);
La interfaz del programa es:
Retornar
3 de 3 30/09/2013 10:07 a.m.

Dibujar: texto con fuentes externas http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=173&in...
Podemos confeccionar aplicaciones e incorporar fuentes True Type externas. Para ello implementaremos una aplicacin
que muestre un texto con una fuente externa.

@+id/layout1:
Procedemos ahora a descargar una fuente del sitio Creamundo y copiamos el archivo de la fuente a la carpeta assets
como se muestra:
1 de 4 30/09/2013 10:07 a.m.

@Override

}
@Override
return true;
}

super(context);
}

2 de 4 30/09/2013 10:07 a.m.


Typeface face = Typeface.createFromAsset(getAssets(),
"Action Man Shaded.ttf");
pincel1.setTypeface(face);
canvas.drawText("Hola Mundo", 0, 120, pincel1);
}
}
En el mtodo onDraw procedemos a crear una fuente llamando al mtodo createFromAsset e indicando el nombre del
archivo que descargamos de internet (disponga en el segundo parmetro el nombre del archivo que eligi y descarg de
internet):
Typeface face = Typeface.createFromAsset(getAssets(), "Action Man Shaded.ttf");

pincel1.setTypeface(face);
La interfaz del programa es:
3 de 4 30/09/2013 10:07 a.m.

Retornar
4 de 4 30/09/2013 10:07 a.m.

Dibujar: texto sobre un camino http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=174&in...
Si queremos disponer texto no no est horizontal debemos crear un camino indicando los puntos donde pasar el texto.

@+id/layout1:
import android.graphics.Path;
1 de 3 30/09/2013 10:07 a.m.

@Override

}
@Override
return true;
}

super(context);
}

Path camino = new Path();

camino.moveTo(0, alto / 2);
camino.lineTo(40, alto / 2 - 30);
canvas.drawTextOnPath("Hola Mundo Hola Mundo", camino, 0, 0,
pincel1);
}
}
Creamos un objeto de la clase Path e indicamos el primer punto del camino llamando al mtodo moveTo:
Path camino = new Path();

camino.moveTo(0, alto/2);
Luego indicamos todos los otros puntos en forma consecutiva llamando al mtodo lineTo:
camino.lineTo(40, alto/2-30);
2 de 3 30/09/2013 10:07 a.m.

Luego para graficar el texto llamamos al mtodo drawTextOnPath y le pasamos en el segundo parmetro la referencia
del objeto de tipo Path:
canvas.drawTextOnPath("Hola Mundo Hola Mundo",camino, 0, 0, pincel1);
La salida del programa es:
Este proyecto lo puede descargar en un zip desde este enlace:
proyecto042.zip
Retornar
3 de 3 30/09/2013 10:07 a.m.

Dibujar: una imagen http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=175&in...
Para mostrar un archivo jpg, png etc. disponemos en la clase Canvas de un mtodo llamado drawBitmap.
Problema:
Mostrar el contenido de un archivo jpg centrado en la pantalla sabiendo que tiene un tamao de 250 pxeles de ancho
por 200 de alto.

@+id/layout1:
Descargar de internet una imagen y redimensionarla a 250*200 pxeles. Copiar dicho archivo a la carpeta
res/drawable-hdpi de nuestro proyecto (actualizar desde el Eclipse dicha carpeta):
1 de 4 30/09/2013 10:08 a.m.

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
@Override

}
@Override
return true;
}
2 de 4 30/09/2013 10:08 a.m.


super(context);
}

Bitmap bmp = BitmapFactory.decodeResource(getResources(),
R.drawable.imagen1);
canvas.drawBitmap(bmp, (ancho - 250) / 2, (alto - 200) / 2, null);
}
}
Para recuperar la imagen del archivo de la carpeta res/drawable-hdpi debemos utilizar el mtodo decodeResource:
Bitmap bmp=BitmapFactory.decodeResource(getResources(), R.drawable.imagen1);
Una vez que tenemos creado el objeto de la clase Bitmap procedemos a posicionar la imagen en forma centrada en la
pantalla del dispositivo:
canvas.drawBitmap(bmp, (ancho-250)/2,(alto-200)/2, null);
3 de 4 30/09/2013 10:08 a.m.

Retornar
4 de 4 30/09/2013 10:08 a.m.

Evento touch: dibujar un crculo http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=176&in...
Una actividad fundamental es poder detectar cuando el usuario selecciona o toca la pantalla tctil.
Problema:
Desarrollar un programa que dibuje un crculo en la coordenada 100,100. Cuando se presione otra parte de la pantalla
tctil proceder a trasladar el crculo a dicha coordenada.

@+id/layout1:
Ahora codificamos la clase donde se encuentra toda la lgica para capturar el evento onTouch:
1 de 4 30/09/2013 10:08 a.m.

import android.view.MotionEvent;
import android.view.View.OnTouchListener;
public class MainActivity extends Activity implements OnTouchListener {

private int corx, cory;
private Lienzo fondo;
@Override
corx = 100;
cory = 100;
fondo = new Lienzo(this);
fondo.setOnTouchListener(this);
}
@Override
return true;
}
public boolean onTouch(View v, MotionEvent event) {

corx = (int) event.getX();
cory = (int) event.getY();
fondo.invalidate();
return true;
}

super(context);
}

pincel1.setStyle(Paint.Style.STROKE);
canvas.drawCircle(corx, cory, 20, pincel1);
}
}
La clase que captura el evento onTouch debe implementar la interface OnTouchListener (con esto indicamos que la clase
debe implementar el mtodo onTouch:
public class Proyecto044Activity extends Activity implements OnTouchListener{
2 de 4 30/09/2013 10:08 a.m.

Definimos como atributos la coordenada donde se debe dibujar el crculo y la referencia al objeto de la clase Lienzo:
private int corx,cory;

private Lienzo fondo;
En el mtodo onCreate del Activity inicializamos los tres atributos de la clase y mediante el mtodo setOnTouchListener
indicamos que la propia clase capturar el evento onTouch del objeto fondo:
corx=100;
cory=100;
fondo=new Lienzo(this);
linearLayout.addView(fondo);
El mtodo onTouch es el que implementamos de la clase OnTouchListener. En este mtodo mediante el objeto event
obtenemos la coordenada x e y donde el usuario seleccion con el dedo y procedemos a llamar al mtodo invalidate para
que vuelva a pintarse el control fondo (el mtodo invalidate borra el contendio del objeto de la clase Lienzo y vuelve a
ejecutarse el mtodo onDraw):

corx=(int)event.getX();
cory=(int)event.getY();
fondo.invalidate();
return true;
}
El mtodo onDraw pinta el fondo de amarillo, crea un objeto de la clase Paint y procede a dibujar un crculo en las
coordenadas indicadas por los atributos corx y cory:

pincel1.setStyle(Paint.Style.STROKE);
canvas.drawCircle(corx, cory, 20, pincel1);
}
3 de 4 30/09/2013 10:08 a.m.

Retornar
4 de 4 30/09/2013 10:08 a.m.

Evento touch: juego del buscaminas http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=177&in...
Problema:
Implementar el juego del Buscaminas. Crear una grilla de 8*8 celdas.
1 - Creamos un proyecto llamado: BuscaMinas

Lo almacenamos en el paquete: com.androidya.BuscaMinas
Borramos el TextView que agrega automticamente el plug-in de Eclipse y disponemos un Button y un LinearLayout:
Luego codificamos las clases BuscaMinasActivity y Casilla:
package com.androidya.buscaminas;
public class Casilla {

public int x,y,ancho;
public int contenido=0;
public boolean destapado=false;
public void fijarxy(int x,int y, int ancho) {
this.x=x;
this.y=y;
this.ancho=ancho;
1 de 7 30/09/2013 10:08 a.m.

public boolean dentro(int xx,int yy) {

if (xx>=this.x && xx<=this.x+ancho && yy>=this.y && yy<=this.y+ancho)
return true;
else
return false;
}
}
Y la clase:
package com.androidya.buscaminas;
import android.view.MotionEvent;
import android.view.View.OnTouchListener;
import android.widget.LinearLayout;
public class MainActivity extends Activity implements OnTouchListener {

private Tablero fondo;
int x, y;
private Casilla[][] casillas;
private boolean activo = true;
@Override
LinearLayout layout = (LinearLayout) findViewById(R.id.layout2);

fondo = new Tablero(this);
layout.addView(fondo);
casillas = new Casilla[8][8];
for (int f = 0; f < 8; f++) {
for (int c = 0; c < 8; c++) {
casillas[f][c] = new Casilla();
}
}
this.disponerBombas();
this.contarBombasPerimetro();
}
@Override
2 de 7 30/09/2013 10:08 a.m.

return true;
}
public void presionado(View v) {

casillas = new Casilla[8][8];
for (int f = 0; f < 8; f++) {
for (int c = 0; c < 8; c++) {
casillas[f][c] = new Casilla();
}
}
this.disponerBombas();
this.contarBombasPerimetro();
activo = true;
fondo.invalidate();
}
@Override
if (activo)
for (int f = 0; f < 8; f++) {
for (int c = 0; c < 8; c++) {
if (casillas[f][c].dentro((int) event.getX(),
(int) event.getY())) {
casillas[f][c].destapado = true;
if (casillas[f][c].contenido == 80) {
Toast.makeText(this, "Booooooooommmmmmmmmmmm",
Toast.LENGTH_LONG).show();
activo = false;
} else if (casillas[f][c].contenido == 0)
recorrer(f, c);
fondo.invalidate();
}
}
}
if (gano() && activo) {
Toast.makeText(this, "Ganaste", Toast.LENGTH_LONG).show();
activo = false;
}
return true;
}
class Tablero extends View {
public Tablero(Context context) {

super(context);
}

int ancho = 0;
if (canvas.getWidth() < canvas.getHeight())
ancho = fondo.getWidth();
else
ancho = fondo.getHeight();
int anchocua = ancho / 8;
Paint paint = new Paint();
paint.setTextSize(20);
Paint paint2 = new Paint();
3 de 7 30/09/2013 10:08 a.m.

paint2.setTextSize(20);
paint2.setTypeface(Typeface.DEFAULT_BOLD);
paint2.setARGB(255, 0, 0, 255);
Paint paintlinea1 = new Paint();
paintlinea1.setARGB(255, 255, 255, 255);
int filaact = 0;
for (int f = 0; f < 8; f++) {
for (int c = 0; c < 8; c++) {
casillas[f][c].fijarxy(c * anchocua, filaact, anchocua);
if (casillas[f][c].destapado == false)
paint.setARGB(153, 204, 204, 204);
else
paint.setARGB(255, 153, 153, 153);
canvas.drawRect(c * anchocua, filaact, c * anchocua
+ anchocua - 2, filaact + anchocua - 2, paint);
// linea blanca
canvas.drawLine(c * anchocua, filaact, c * anchocua
+ anchocua, filaact, paintlinea1);
canvas.drawLine(c * anchocua + anchocua - 1, filaact, c
* anchocua + anchocua - 1, filaact + anchocua,
paintlinea1);
if (casillas[f][c].contenido >= 1
&& casillas[f][c].contenido <= 8
&& casillas[f][c].destapado)
canvas.drawText(
String.valueOf(casillas[f][c].contenido), c
* anchocua + (anchocua / 2) - 8,
filaact + anchocua / 2, paint2);
if (casillas[f][c].contenido == 80
&& casillas[f][c].destapado) {
Paint bomba = new Paint();
bomba.setARGB(255, 255, 0, 0);
canvas.drawCircle(c * anchocua + (anchocua / 2),
filaact + (anchocua / 2), 8, bomba);
}
}
filaact = filaact + anchocua;
}
}
}
private void disponerBombas() {

int cantidad = 8;
do {
int fila = (int) (Math.random() * 8);
int columna = (int) (Math.random() * 8);
if (casillas[fila][columna].contenido == 0) {
casillas[fila][columna].contenido = 80;
cantidad--;
}
} while (cantidad != 0);
}
private boolean gano() {

int cant = 0;
for (int f = 0; f < 8; f++)
for (int c = 0; c < 8; c++)
if (casillas[f][c].destapado)
4 de 7 30/09/2013 10:08 a.m.

cant++;
if (cant == 56)
return true;
else
return false;
}
private void contarBombasPerimetro() {

for (int f = 0; f < 8; f++) {
for (int c = 0; c < 8; c++) {
if (casillas[f][c].contenido == 0) {
int cant = contarCoordenada(f, c);
casillas[f][c].contenido = cant;
}
}
}
}
int contarCoordenada(int fila, int columna) {

int total = 0;
if (fila - 1 >= 0 && columna - 1 >= 0) {
if (casillas[fila - 1][columna - 1].contenido == 80)
total++;
}
if (fila - 1 >= 0) {
if (casillas[fila - 1][columna].contenido == 80)
total++;
}
if (fila - 1 >= 0 && columna + 1 < 8) {
if (casillas[fila - 1][columna + 1].contenido == 80)
total++;
}
if (columna + 1 < 8) {
if (casillas[fila][columna + 1].contenido == 80)
total++;
}
if (fila + 1 < 8 && columna + 1 < 8) {
if (casillas[fila + 1][columna + 1].contenido == 80)
total++;
}
if (fila + 1 < 8) {
if (casillas[fila + 1][columna].contenido == 80)
total++;
}
if (fila + 1 < 8 && columna - 1 >= 0) {
if (casillas[fila + 1][columna - 1].contenido == 80)
total++;
}
if (columna - 1 >= 0) {
if (casillas[fila][columna - 1].contenido == 80)
total++;
}
return total;
}
private void recorrer(int fil, int col) {

if (fil >= 0 && fil < 8 && col >= 0 && col < 8) {
if (casillas[fil][col].contenido == 0) {
casillas[fil][col].destapado = true;
5 de 7 30/09/2013 10:08 a.m.

casillas[fil][col].contenido = 50;
recorrer(fil, col + 1);
recorrer(fil, col - 1);
recorrer(fil + 1, col);
recorrer(fil - 1, col);
recorrer(fil - 1, col - 1);
recorrer(fil - 1, col + 1);
recorrer(fil + 1, col + 1);
recorrer(fil + 1, col - 1);
} else if (casillas[fil][col].contenido >= 1
&& casillas[fil][col].contenido <= 8) {
casillas[fil][col].destapado = true;
}
}
}
La interfaz visual de la aplicacin es:
Este proyecto lo puede descargar en un zip desde este enlace: BuscaMinas.zip
6 de 7 30/09/2013 10:08 a.m.

Retornar
7 de 7 30/09/2013 10:08 a.m.

Archivo strings.xml http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=178&in...
El archivo strings.xml se utiliza para almacenar todas las constantes de cadenas de caracteres que se necesitan en un
programa (por ejemplo las etiquetas de los objetos Button, los textos fijos de los controles TextView y todos los controles que
muestran un texto fijo en el dispositivo)
La idea fundamental es tener todos los mensajes que muestra nuestra aplicacin en un archivo (strings.xml)
Ya veremos en el prximo concepto que uno de las ventajas que presenta esta agrupacin de string es la posibilidad de
facilitar la implementacin de aplicaciones en mltiples idiomas.
Problema:
Crear un proyecto que solicite la carga de dos valores. Mediante dos RadioButton permitir seleccionar si queremos sumar
o restar. Cuando se presione un botn mostrar en un TextView el resultado de la operacin.

El Plugin de Eclipse nos crea automticamente el archivo strings.xml en la carpeta values que se encuentra en la carpeta
res:
Si vemos en su interior podemos ver que ya define tres string llamados app_name, hello_world y menu_settings:
Lo que se encuentra entre las marcas string es lo que se visualizar, por ejemplo en la constante hello_world se
1 de 8 30/09/2013 10:08 a.m.

almacena el valor "Hello world!". En este archivo crearemos todas las constantes a incluir en nuestro programa. Si vemos
en la parte inferior de la ventana donde se visualiza el archivo xml hay una pestaa llamada Resource que nos permite
ingresar las distintas constantes de una forma visual:
Creamos primero la interfaz visual disponiendo dos controles de tipo EditText, un RadioGroup con dos RadioButton, un
Button y un TextView donde se muestra el resultado de la operacin:
Ahora si crearemos los mensajes que mostrarn los dos RadioButton y el Button. Para esto seleccionamos el archivo
strings y procedemos a crear las tres constantes:
2 de 8 30/09/2013 10:08 a.m.

Una vez que tenemos abierto el archivo strings.xml en modo "Resources" procedemos a presionar el botn "Add..." y
seleccionamos "String":
Creamos los nombres de las constantes y los valores, por ejemplo para el mensaje que mostrar el primer RadioButton
llamamos la constante con el nombre "radiosuma" y el valor que almacena es "Sumar"
De forma similar creamos las constantes "radioresta" con el valor "Restar" y el botn para operar lo llamamos
"botonoperacion" con el valor "Operar". Si seleccionamos la pestaa strings.xml luego podemos ver las tres constantes
3 de 8 30/09/2013 10:08 a.m.

que hemos creado :
Ahora debemos asociar estas constantes a los controles visuales. Seleccionamos el archivo activity_main.xml y
seleccionamos primero el primer RadioButton y buscamos la propiedad Text, presionamos el botn que aparece a la
derecha:
En este dilogo seleccionamos la constante de string que acabamos de crear ("radiosuma"):
4 de 8 30/09/2013 10:08 a.m.

Ahora tenemos asociada la constante "radiosuma" con la propiedad text del control RadioButton. Lo mismo podramos
haber hecho esto escribiendo en la propiedad @string/radiosuma (@string lo utilizamos para indicar que el siguiente
dato despus de la barra se trata de una constante definida en el archivo strings.xml)
Utilizar el dilogo de seleccin de recursos nos facilita no tener que recordar todas las constantes.
Lo mismo hacemos para asociar las constantes para el segundo RadioButton y el Button de operar. Es decir las
propiedades text del radio1 debe quedar con el valor "@string/radioresta" y el valor de la propiedad text del objeto
button1 debe ser "@string/botonoperacion"
Como vemos cuando asociamos las propiedades text de los controles con las constantes automticamente vemos en
pantalla que los textos de los controles se actualizan con los valores almacenados en dichas constantes.
Para que funcione nuestro programa inicializamos la propiedad On click del Button con el mtodo que sumar o restar:
5 de 8 30/09/2013 10:08 a.m.

El cdigo fuente del programa ser:
import android.widget.RadioButton;

EditText et1, et2;
RadioButton rb1, rb2;
TextView tv1;
@Override
rb1 = (RadioButton) findViewById(R.id.radio0);
rb2 = (RadioButton) findViewById(R.id.radio1);
tv1 = (TextView) findViewById(R.id.textView1);
}
6 de 8 30/09/2013 10:08 a.m.

@Override
return true;
}
public void operar(View v) {

int v1 = Integer.parseInt(et1.getText().toString());
int v2 = Integer.parseInt(et2.getText().toString());
if (rb1.isChecked()) {
int suma = v1 + v2;
tv1.setText(String.valueOf(suma));
} else if (rb2.isChecked()) {
int resta = v1 - v2;
tv1.setText(String.valueOf(resta));
}
}
El resultado final del programa en el dispositivo es:
7 de 8 30/09/2013 10:08 a.m.

Retornar
8 de 8 30/09/2013 10:08 a.m.

Internacionalizacin y archivo strings.xml http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=179&in...
La internacionalizacin de un programa en Android se resuelve implementando varios archivos strings.xml (uno por cada
idioma que necesitemos implementar)
Problema:
Modificar el proyecto025 de tal manera que muestre su interfaz en castellano o ingles segn la configuracin del idioma
seleccionado en el dispositivo.
Crearemos primero una nueva carpeta llamada values-en (las abreviaturas para los distintos lenguajes los podemos ver
en la pgina ISO 639-1 Code (segunda columna)
Es decir creamos otra carpeta con el mismo nombre (values) ms un guin y la extensin del lenguaje a implementar:
Seleccionamos el archivo strings.xml de la carpeta values presionamos el botn derecho y elegimos copiar, ahora nos
vamos a la otra carpeta (values-en) y elegimos copiar. Procedemos a traducir los valores almacenados en cada string:
Solamente con esto ya tenemos nuestra aplicacin funcionando en dos idiomas. Para probar debemos acceder al
emulador de Android y configurarlo en ingls (tecla home -> tecla menu -> configuracin > Idioma y teclado >
Seleccionar idioma -> "English (United Stated)
Luego de esto lanzamos la aplicacin y deberemos ver la interfaz con los string que configuramos en el archivo
strings.xml de la carpeta values-en:
1 de 2 30/09/2013 10:08 a.m.

Internacionalizacin y archivo strings.xml http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=179&in...
Retornar
2 de 2 30/09/2013 10:08 a.m.

Localizacin y archivo strings.xml http://www.javaya.com.ar/androidya/detalleconcepto.php?codigo=180&in...
Hemos visto si queremos tener traducida nuestra aplicacin a varios idiomas debemos utilizar el concepto de
internacionalizacin. Pero hay muchos casos donde queremos hilar ms fino. Por ejemplo el ingles de Estados Unidos
no es exactamente igual que el ingles de Inglaterra o de Autralia. Para estas situaciones podemos crear varios archivos
strings.xml para distintas localidades que tienen el mismo idioma.
Problema:
Modificar el proyecto025 de tal manera que muestre su interfaz no solo para el idioma por defecto (espaol) e ingles, sino
para el portugus de Brasil y el portugus de Portugal.
Las abreviaturas para los distintos lenguajes los podemos ver en la pgina ISO 639-1 Code (segunda columna) y para
obtener las distintas regiones utilizamos la tabla ISO 3166-1-alpha-2
Luego debemos crear una carpeta con el nombre values, luego un guin y el cdigo de internacionalizacin, finalmente
otro guin el caracter r y finalmente el cdigo de regin.
En nuestro problemas crearemos dos directorios llamados:
values-pt-rBR
values-pt-rPT
Luego de crear estos dos directorios copiaremos el archivo strings.xml de la carpeta values y procederemos a traducirlo
al portugus de Brasil y al portugus de Portugal.
Luego de crear las dos carpetas copiar el archivo strings.xml y proceder a traducirlo primero al portugus de Brasil y
luego en la otra carpeta traducirlo al portugus de Portugal, solo nos resta compilar y probar la aplicacin.
Para probar debemos acceder al emulador de Android y configurarlo en portugus de Brasil (tecla home -> tecla menu ->
configuracin > Idioma y teclado > Seleccionar idioma -> "Portugus (Brasil)
1 de 4 30/09/2013 10:09 a.m.

Seguidamente ejecutar la aplicacin y ver como resultado que tenemos los mensajes que definimos en el archivo
strings.xml asociado con el portugus de Brasil:
2 de 4 30/09/2013 10:09 a.m.

Lo mismo podemos luego configurar el idioma portugus de Portugal y obtener como resultado en una nueva ejecucin
del programa:
3 de 4 30/09/2013 10:09 a.m.

Retornar
4 de 4 30/09/2013 10:09 a.m.

CACIC Fundesco AndroidYa PDF

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

CACIC Fundesco AndroidYa PDF

Загружено:

Авторское право:

Доступные форматы

La Fundacin para el Desarrollo del Conocimiento, Fundesco, es una entidad sin fines de lucro,

En su pgina web www.fundesco.org.ar podrn encontrarse ms detalles sobre los mismos.

IAFIP - Instituto Argentino de Capacitacin e Investigacin en Programacin

Generar y proporcionar cursos de induccin a disciplinas de equipo, con especial

Director General: Dr. Oscar Ricardo Bruno

Descarga de herramientas necesarios para programar para Android.

3 - El tercer paso es descomprimir el ADT, por ejemplo en la raiz de c:

4 - El cuarto paso es ejecutar el Eclipse:

Entramos a la carpeta eclipse y ejecutamos eclipse.exe

Debe aparecer una ventana de inicio similar a esta:

1 de 4 30/09/2013 09:45 a.m.

2 de 4 30/09/2013 09:45 a.m.

3 de 4 30/09/2013 09:45 a.m.

Ya tenemos todo configurado para el desarrollo de aplicaciones Android.

4 de 4 30/09/2013 09:45 a.m.

1 de 6 30/09/2013 09:46 a.m.

2 de 6 30/09/2013 09:46 a.m.

Si seleccionamos la otra pestaa podemos visualizar el archivo activity_main.xml en formato de texto:

3 de 6 30/09/2013 09:46 a.m.

4 de 6 30/09/2013 09:46 a.m.

Ahora podemos ver nuestra primer aplicacin corriendo en el emulador de Android:

5 de 6 30/09/2013 09:46 a.m.

Este proyecto lo puede descargar en un zip desde este enlace: proyecto001.zip

6 de 6 30/09/2013 09:46 a.m.

La interfaz visual debe quedar algo semejante a esto:

1 de 12 30/09/2013 09:46 a.m.

2 de 12 30/09/2013 09:46 a.m.

3 de 12 30/09/2013 09:46 a.m.

4 de 12 30/09/2013 09:46 a.m.

De la pestaa "Form Widgets" arrastramos un control de tipo "Button":

5 de 12 30/09/2013 09:46 a.m.

Abrimos seguidamente el archivo MainActivity.java que lo podemos ubicar en la carpeta src:

6 de 12 30/09/2013 09:46 a.m.

El cdigo fuente de la clase MainActivity.java es:

public class MainActivity extends Activity {

7 de 12 30/09/2013 09:46 a.m.

public class MainActivity extends Activity {

private EditText et1,et2;

private EditText et1,et2;

y luego presionar las teclas Control-Shift-O

private EditText et1,et2;

public void onCreate(Bundle savedInstanceState) {

8 de 12 30/09/2013 09:46 a.m.

public class MainActivity extends Activity {

private EditText et1,et2;

//Este mtodo se ejecutar cuando se presione el botn

Debemos importar lar clase View (Control-Shift-O)

9 de 12 30/09/2013 09:46 a.m.

public void sumar(View view) {

La clase completa queda entonces como:

public class MainActivity extends Activity {

private EditText et1,et2;

10 de 12 30/09/2013 09:46 a.m.

//Este mtodo se ejecutar cuando se presione el botn

11 de 12 30/09/2013 09:46 a.m.

Este proyecto lo puede descargar en un zip desde este enlace: proyecto002.zip

12 de 12 30/09/2013 09:46 a.m.

1 de 4 30/09/2013 09:47 a.m.

Por ltimo agreguemos un botn y un TextView para mostrar el resultado

Y el tercer TextView con los valores:

2 de 4 30/09/2013 09:47 a.m.

El cdigo fuente de la clase MaintActivity es:

public class MainActivity extends Activity {