Manual de android parte 1

1 - Instalación de las herramientas
necesarias para programar para
Android Studio
Descarga de herramientas necesarios para programar para Android con el
Android Studio
1 - Primero debemos instalar el compilador de Java y la máquina virtual. Estas
herramientas las podemos descargar de:
Java SE Development Kit (JDK).
2 - El segundo paso es la descarga del Android Studio (que contiene todo lo necesario
para comenzar el desarrollo de aplicaciones en Android), lo hacemos del sitio :
Android SDK.
Ahora procedemos a su instalación en el equipo ejecutando el archivo que acabamos de
descargar:
Dejamos por defecto para que instale el Android Studio, el Android SDK, Android
Virtual Device etc.:

Dejamos con los valores por defecto en las siguientes pantallas de instalación.

3 - El tercer paso es ejecutar el Android Studio para poder empezar a desarrollar para
Android:
La primera vez que lo ejecutamos elegimos el tipo de configuración "Standard":
Seguidamente se instalan las últimas componentes necesarias:

Finalmente aparece el siguiente diálogo desde donde podemos crear nuestro primer
proyecto:

Desde esta interfaz siempre procedemos para crear un nuevo proyecto.
2 - Pasos para crear el primer proyecto
Android Studio
Una vez que iniciamos el entorno del Android Studio aparece el diálogo principal:

Elegimos la opción "Start a New Android Studio project"
Ahora aparecerán una serie de ventanas para configurar el proyecto, el primer diálogo
debemos especificar el Nombre de la aplicación, la url de nuestra empresa (que será el
nombre del paquete que asigna java para los archivos fuentes) y la ubicación en el disco
de nuestro proyecto:

En el segundo diálogo procedemos a especificar la versión de Android mínima donde se
ejecutará la aplicación que desarrollemos (dejaremos la versión 4.0.3):

El tercer diálogo especificamos el esqueleto básico de nuestra aplicación,
seleccionaremos "Empty Activity" si tenemos el Android Studio 2.0 o "Blank Activity"
si tenemos el Android Studio 1.x (es decir se generará el código básico para que nuestra
aplicación tenga una ventana):

Finalmente el último diálogo tenemos que indicar el nombre de la ventana principal de
la aplicación (Activity Name) y otros datos más que veremos a lo largo del curso
(dejaremos con los nombres por defecto que propone Android Studio):

Tenemos finalmente creado nuestro primer proyecto en Android Studio y podemos
ahora ver el entorno del Android Studio para codificar la aplicación:

El Android Studio nos genera todos los directorios y archivos básicos para iniciar
nuestro proyecto, los podemos ver en el lado izquierdo del entorno de desarrollo:

No haremos en este momento un análisis del significado y objetivo de cada uno de estas
secciones 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 Android Studio nos permite visualizar el contenido en
"Design" o "Text" (es decir en vista de diseño o en vista de código):
Vista de diseño:
Vista de código:

El Android Studio 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 (más
adelante analizaremos este layout)

Ya veremos que podemos modificar todo este archivo para que se adapte a la aplicación
que queremos desarrollar.
A lo largo de este curso iremos viendo los objetivos de cada una de las secciones que
cuenta el Android Studio para implementar la interfaz, codificar en java las
funcionalidades de la aplicación etc.
Antes de probar la aplicación en el emulador de un dispositivo Android procederemos a
hacer un pequeño cambio a la interfaz que aparece en el celular: borraremos la label que
dice "Hello World" (simplemente seleccionando con el mouse dicho elemento y
presionando la tecla delete) y de la "Palette" arrastraremos un "Button" al centro del
celular y en la ventana "Properties" estando seleccionado el "Button" cambiaremos la
propiedad "text" por la cadena "Hola Mundo":
Para ejecutar la aplicación presionamos el triángulo verde o seleccionamos del menú de
opciones "Run -> Run app" y en este diálogo procedemos a dejar seleccionado el
emulador por defecto que aparece (Nexus 5X) y presionamos el botón "OK" (si no tiene
ningún emulador puede crear uno):

Luego de un rato aparecerá el emulador de Android en pantalla (el arranque del emulador
puede llevar más de un minuto), es IMPORTANTE tener en cuenta que una vez que el
emulador se ha arrancado no lo debemos cerrar cada vez que hacemos cambios en nuestra
aplicación o codificamos otras aplicaciones, sino que volvemos a ejecutar la aplicación
con los cambios y al estar el emulador corriendo el tiempo que tarda hasta que aparece
nuestro programa en el emulador es muy reducido.
Cuando terminó de cargarse el emulador debe aparecer nuestra aplicación ejecutándose:

3 - Capturar el clic de un botón
Problema:
Confeccionar un programa que permita la carga de dos números en controles de tipo
EditText. Mostrar mensajes que soliciten 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:
Crear un proyecto llamado:Proyecto002.
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
Android Studio. Ahora desde la ventana "Palette" seleccionamos de la pestaña
"Widgets" el control "Medium Text" (es de la clase TextView) y lo arrastramos a la
ventana de diseño de nuestra interfaz a la parte superior izquierda:

Ahora lo seleccionamos y en la ventana de propiedades (Properties) especificamos la
propiedad text (como habíamos visto anteriormente) disponemos el texto "Ingrese el

También vamos a especificar la propiedad "id", y le asignaremos el valor tv1
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 pestaña "Text Fields" y
arrastramos el "Number" (pertenece a la clase EditText)

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 "Medium Text" y "Number"
(inicializamos las propiedades respectivas) Definimos los id con los nombres tv2 y et2,
el resultado visual debe ser algo semejante a esto:

De la pestaña "Widgets" arrastramos un control de tipo "Button":
Inicializamos la propiedad text con el texto "Sumar" y la propiedad id la dejamos con el
valor ya creado llamado "button".
Para terminar con nuestra interfaz visual arrastramos un tercer objeto de tipo "Medium
Text" (es de la clase 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 aplicación aparece la interfaz visual correctamente
pero cuando presionemos el botón no mostrará la suma.
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 appjavaarcomtutorialesyaproyecto002MainActivity:

La clase MainActivity hereda de la clase AppCompatActivity. La clase
AppCompatActivity representa una ventana de Android y tiene todos los métodos
necesarios para crear y mostrar los objetos que hemos dispuesto en el archivo xml.
El código fuente de la clase MainActivity.java es:
package ar.com.tutorialesya.proyecto002;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
public class MainActivity extends AppCompatActivity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
}
Como mínimo se debe sobrescribir el método onCreate heredado de la clase
AppCompatActivity donde procedemos a llamar al método 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 más
adelante que el Android Studio se encarga de crear la clase R en forma automática y sirve
como puente entre el archivo xml y nuestra clase MainActivity)
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, la forma más fácil de importar las clases
es una vez que definimos el objeto por ejemplo private TextView tv3 veremos que
aparece en rojo el nombre de la clase y si disponemos el cursor sobre el nombre de la
clase y presionamos las teclas "Alt" y "Enter" luego el Android Studio codifica
automáticamente la línea que importa la clase: import android.widget.TextView;):
import android.widget.EditText;
import android.widget.TextView;
private EditText et1,et2;
private TextView tv3;
@Override
}
}
Recordar que la forma más fácil de importar las clases EditText y TextView es tipear
las dos líneas:
y luego presionar las teclas "Alt" y "Enter" en cada nombre de clase que se debe
importar
Esto hace que se escriban automáticamente los 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. También 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 método onCreate debemos enlazar estas variables con los objetos definidos en el
archivo XML, esto se hace llamando al método findViewById:
@Override
et1=(EditText)findViewById(R.id.et1);
tv3=(TextView)findViewById(R.id.tv3);
}
Al método findViewById debemos pasar la constante creada en la clase R (recordemos
que se crea automáticamente 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 paréntesis el nombre de la clase)
Ya tenemos almacenados en las variables las referencias a los tres objetos que se crean
al llamar al método:setContentView(R.layout.main); .
Ahora planteamos el método que se ejecutará cuando se presione el botón (el método
debe recibir como parámetro un objeto de la clase View) En nuestro ejemplo lo llamé
sumar:
import android.view.View;
@Override

}
//Este método se ejecutará cuando se presione el botón
public void sumar(View view) {
}
}
Debemos importar lar clase View ("Alt" y "Enter" estando el cursor sobre el nombre de
la clase "View")
Ahora debemos ir al archivo XML e inicializar la propiedad onClick del objeto button
con el nombre del método que acabamos de crear (este paso es fundamental para que el
objeto de la clase Button pueda llamar al método sumar que acabamos de crear):

Finalmente implementaremos la lógica 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
}
int suma=nro1+nro2;
tv3.setText(resu);
}
}
Si ejecutamos nuestro programa podemos ver ahora que luego de cargar dos valores al
presionar el botón aparece en el tercer TextView el resultado de la suma de los dos
EditText:

4 - Controles RadioGroup y
RadioButton
El objetivo de este concepto es practicar la implementación 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.

Crear un proyecto llamado Proyecto003.
Problema:
Realizar la carga de dos números en controles de tipo EditText. Mostrar un mensaje que
solicite la carga de los valores. Disponer dos controles de tipo RadioButton para
seleccionar si queremos sumar o restar dichos valores. Finalmente mediante un control
de tipo Button efectuamos la operación 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 pestaña Containers de la "Palette"):

Ahora debemos arrastrar dos controles de la clase RadioButton de la pestaña "Widgets"
dentro del RadioGroup

Nuestro problema solo requiere dos controles de tipo RadioButton.
Otra cosa muy importante es seleccionar nuevamente el control RadioGroup y cambiar
la propiedad layout:heigth con el valor wrap_parent (para que el control RadioGroup
solo ocupe el espacio de los dos controles RadioButton):

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 también cambiar los id de los controles EditText por et1 y et2 (igual que
en el problema anterior)
Por último agreguemos un botón y un TextView para mostrar el resultado
Inicializamos las propiedades del botón con los valores:

id : button
text : operar
Y el tercer "Medium Text" (TextView) con los valores:
id : tv3
text : resultado
Podemos controlar en la ventana "Component Tree" el id definido para cada control
(tv1, et1, tv2, et2, radioGroup, r1, r2, button, tv3)
También podemos observar de que clase es cada control visual y el texto de la
propiedad text para aquellos controles que tienen sentido su inicialización.

Captura del evento clic del button e identifiación del RadioButton
seleccionado.
El código fuente de la clase MaintActivity es:
import android.widget.RadioButton;
private RadioButton r1,r2;
@Override
r1=(RadioButton)findViewById(R.id.r1);
}
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 button con el método operar. Para esto similar al
problema anterior seleccionamos el control button y cambiamos la propiedad onClick
por el valor operar (si no hacemos esto nunca se ejecutará el método operar de la clase
MainActivity)
Como podemos ver el código fuente es igual al problema anterior. Tenemos dos objetos
más que debemos inicializar en el método onCreate:

Las variables r1 y r2 son de la clase RadioButton y son necesarios en el método operar
para verificar cual de los dos RadioButton están seleccionados. La clase RadioButton
tiene un método llamado isChecked que retorna true si dicho elemento está
seleccionado:
int suma=nro1+nro2;
tv3.setText(resu);
} else
tv3.setText(resu);
}
}
5 - Control CheckBox
El objetivo de este concepto es seguir practicando lo visto hasta ahora para la creación
de un proyecto con Android Studio e incorporar el control visual CheckBox
Problema:
Realizar la carga de dos números en controles de tipo EditText ("Number"). Mostrar un
mensaje que solicite la carga de los valores. 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 operación respectiva. Mostramos el o los
resultados en un TextView ("Medium Text").
Lo nuevo en este problema es la inserción de dos objetos de la clase CheckBox que se
encuentra en la pestaña "Widgets":

Luego la interfaz gráfica final para este problema y los nombres de los controles los
podemos ver en la ventana "Component Tree":

No olvidemos inicializar la propiedad onClick del objeto button con el valor "operar"
(es el nombre del método a ejecutarse cuando se presione el botón y lo implementa la
clase que hacemos)
Código fuente:
import android.widget.CheckBox;

private CheckBox checkBox1,checkBox2;
@Override
checkBox1=(CheckBox)findViewById(R.id.checkBox);
checkBox2=(CheckBox)findViewById(R.id.checkBox2);
}
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 método onCreate los inicializamos con los objetos definidos en el archivo XML:
checkBox1=(CheckBox)findViewById(R.id.checkBox);
checkBox2=(CheckBox)findViewById(R.id.checkBox2);
En el método operar debemos definir dos if a la misma altura ya que los dos controles
de tipo CheckBox pueden estar seleccionados simultáneamente. Definimos una variable
de tipo String y la inicializamos con cadena vacía para el caso en que los dos CheckBox
no estén seleccionados:
String resu="";
int suma=nro1+nro2;
resu="La suma es: "+ suma;
}

resu=resu + " La resta es: "+ resta;
}
tv3.setText(resu);
Cuando ejecutamos el programa en el emulador tenemos como resultado:
http://www.javaya.com.ar/androidya/androidstudioya/detalleconcepto.php?codigo=5&inicio=
0

6 - Control Spinner
El objetivo de este concepto es seguir practicando 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:
Realizar la carga de dos números en controles de tipo EditText. Mostrar un
mensaje que solicite la carga de los valores. 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 operación
respectiva. Mostramos el resultado en un TextView.
Lo nuevo en este problema es la inserción de un control de tipo Spinner que se
encuentra en la pestaña "Widgets" (cuando lo arrastremos podemos
redimensionarlo con el mouse para que ocupe todo el ancho del dispositivo):

Dejamos la propiedad id con el valor spinner (valor por defecto que crea el
Android Studio al insertar un objeto).
En la siguiente imagen en la ventana "Component Tree" del Android Studio
podemos observar los objetos dispuestos en el formulario, sus id, sus textos y
de que clase son cada uno:

No olvidemos inicializar la propiedad onClick del objeto button con el valor
"operar" (dicho nombre es el método que debemos implementar)
Código fuente:

import android.widget.ArrayAdapter;
import android.widget.Spinner;
public class MainActivity extends
AppCompatActivity {
private Spinner spinner1;
@Override
protected void onCreate(Bundle
savedInstanceState) {
spinner1 = (Spinner)
findViewById(R.id.spinner);
String
[]opciones={"sumar","restar","multiplicar","divi
dir"};
ArrayAdapter adapter = new
ArrayAdapter(this,android.R.layout.simple_spinne
r_item, opciones);
spinner1.setAdapter(adapter);
}
//Este método se ejecutará cuando se
presione el botón
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 método onCreate obtenemos la referencia al control visual declarado en el
archivo XML:
spinner1 = (Spinner) findViewById(R.id.spinner);
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_i
tem, opciones);
Al constructor le pasamos como primer parámetro la referencia de nuestro
AppCompatActivity (this), el segundo parámetro indica el tipo de Spinner,
pudiendo ser las constantes:
android.R.layout.simple_spinner_item
android.R.layout.simple_spinner_dropdown_item
El tercer parámetro es la referencia del vector que se mostrará.
Luego llamamos al método setAdapter de la clase Spinner pasando la referencia
del objeto de la clase ArrayAdapter que acabamos de crear:
spinner1.setAdapter(adapter);

En el método operar que se ejecuta cuando presionamos el botón "OPERAR" y
donde 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);
}
7 - Control ListView (con una lista de
String)
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)
En este primer ejemplo mostraremos una lista de String (es decir cada elemento
de la lista es un String, veremos más adelante que podemos tener listas de
objetos de otro tipo: imágenes, íconos, varios String por elemento etc.)
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 pestaña "Containers".
Problema:

Disponer un ListView con los nombres de paises de sudamérica. Cuando se
seleccione un país mostrar en un TextView ("Large Text") la cantidad de
habitantes del país seleccionado.
La interfaz visual a implementar es la siguiente (primero disponemos un
TextView ("Large Text") (llamado tv1) y un ListView (llamado listView por
defecto)):
Código fuente:

import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.ListView;
AppCompatActivity {
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" };
private ListView lv1;
@Override
lv1
=(ListView)findViewById(R.id.listView);
ArrayAdapter adapter = new
ArrayAdapter(this,android.R.layout.simple_list_i
tem_1, paises);
lv1.setAdapter(adapter);
lv1.setOnItemClickListener(new
AdapterView.OnItemClickListener() {
@Override
public void onItemClick(AdapterView
adapterView, View view, int i, long l) {

tv1.setText("Población de "+
lv1.getItemAtPosition(i) + " es "+
habitantes[i]);
}
});
}
}
Primero definimos dos vectores paralelos donde almacenamos en uno los
nombres de países y en el otro almacenamos la cantidad de habitantes de dichos
países:
private String[]
paises={"Argentina","Chile","Paraguay","Bolivia","Peru",
"Ecuador","Brasil","Colombia","Venezuela","Uruguay"};
private String[]
habitantes={"40000000","17000000","6500000","10000000","300
00000",
"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 método onCreate obtenemos la referencia a los dos objetos:
lv1 =(ListView)findViewById(R.id.listView);
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_item
_1, paises);
lv1.setAdapter(adapter);
Llamamos al método setOnItemClicListener de la clase ListView y le pasamos
como parámetro una clase anónima que implementa la interfaz
OnItemClickListener (dicha interfaz define el método onItemClick que se dispara
cuando seleccionamos un elemento del ListView):
lv1.setOnItemClickListener(new
AdapterView.OnItemClickListener() {
@Override
public void onItemClick(AdapterView
adapterView, View view, int i, long l) {
tv1.setText("Población de "+
lv1.getItemAtPosition(i) + " es "+ habitantes[i]);
}
});

Para codificar esta clase anónima podemos utilizar la facilidad que nos brinda el
Android Studio para generarla automáticamente, para esto tipeamos:
Luego presionamos la tecla "Enter" y el Android Studio automáticamente nos
genera la clase anónima implementando la interfaz onItemClick.
Dentro del método onItemClick modificamos el contenido del TextView con el
nombre del país y la cantidad de habitantes de dicho país. Este método recibe
en el tercer parámetro la posición del item seleccionado del ListView.
Cuando ejecutamos el proyecto podemos ver una interfaz en el emulador similar
a esta:

8 - Control ImageButton
Hemos visto la creación de objetos de la clase Button, ahora veremos otra clase
muy similar a la anterior llamada ImageButton que tiene la misma filosofía 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
teléfono. 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 píxeles.
Nombre del archivo: telefono.jpg
Ahora copiamos el archivo a la carpeta de recursos de nuestro proyecto :
Proyecto007/app/src/main/res/mipmap-mdpi
Esto lo podemos hacer desde el administrador de archivos del sistema operativo.
En la ventana "Project" cambiamos a vista "Project Files" y navegamos hasta la
carpeta donde copiamos el archivo, vemos que el archivo está en dicha carpeta:

Esto solo a efectos de ver que el proyecto se actualiza con los archivos de
recursos que copiamos a las carpetas mipmap-mdpi.
Ahora insertaremos el objeto de la clase ImageButton en el formulario de nuestra
aplicación. La clase ImageButton se encuentra en la pestaña "Widgets":

Seguidamente seleccionamos la propiedad "src" del objeto ImageButton que
acabamos de disponer y en dicho diálogo buscamos el nombre de la imagen que
copiamos en la carpeta drawable-mdpi:

Inicializamos la propiedad ID con el nombre bi1
Agreguemos un TextView a nuestra aplicación y configuremos sus propiedades
ID (con tv1) y text. Luego la interfaz visual debe ser similar a:

Código fuente:

AppCompatActivity {
@Override
}
//Este método se ejecutará cuando se
presione el ImageButton
public void llamar(View view) {
tv1.setText("Llamando");
}
}
Definimos el atributo de tipo TextView:
TextView tv1;
Enlazamos el control definido en el archivo XML y la variable de java:
Implementamos el método 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
método "llamar" (recordemos que esto lo hacemos accediendo a la propiedad
onClick en la ventana de "Properties")
Este proyecto lo puede descargar en un zip desde este enlace: proyecto007.zip
Comentarios extras de este control.
Cuando copiamos el archivo lo hicimos a la carpeta:
mipmap-mdpi
Pero vimos que hay otras carpetas con nombres similares:
mipmap-mdpi
mipmap-hdpi
mipmap-xhdpi
mipmap-xxhdpi
mipmap-xxxhdpi
El objetivo de estas otras carpetas es guardar las mismas imágenes pero con
una resolución mayor si la guardamos en mipmap-hdpi.

Esto se hace si queremos que nuestra aplicación sea más flexible si se ejecuta
en un celular, en un tablet, en un televisor etc.
Debemos tener en cuenta estos tamaños:
En la carpeta res/mipmap-mdpi/
(guardamos la imagen con el tamaño original)
En la carpeta res/mipmap-hdpi/
(guardamos la imagen con el tamaño del 150% con respecto al
de la carpeta mipmap-mdpi)
En la carpeta res/mipmap-xhdpi/
En la carpeta res/mipmap-xxhdpi/
En la carpeta res/mipmap-xxxhdpi/
9 - Notificaciones sencillas mediante
la clase Toast
Android permite mostrar una ventana emergente temporal que informa al usuario
mediante un mensaje que aparece en la pantalla por un lapso pequeño de tiempo
(luego de pasado un tiempo la ventana desaparece).
Esta ventana que se superpone a la interfaz que se está mostrando en ese
momento se administra mediante una clase llamada Toast.
Problema:
Generar un número aleatorio entre 1 y 100000. Mostrar mediante una ventana
emergente dicho número por un lapso de tiempo. Luego mediante un control
EditText ("Number") pedir al operador que ingrese el número que vio en la
pantalla. Cuando se presione un botón controlar el número generado
aleatoriamente con el que ingresó el usuario y mediante otro Toast informar si
acertó o no.
Lo primero que hacemos es crear la interfaz siguiente:

Es decir que disponemos un TextView ("Medium Text"), EditText ("Number") y
un Button. Dejamos por defecto los nombres asignados a las id de cada uno de
estos objetos: textView, editText y button.
Luego seleccionamos el botón de la interfaz visual e inicializamos la propiedad
onClick con el nombre del método que se ejecutará al ser presionado, dicho
nombre debe ser: "controlar" (recordemos que los nombre de métodos en Java
por convención empiezan en minúsculas)

Código fuente:
import android.widget.Toast;
AppCompatActivity {
private EditText et1;
private int num;
@Override
et1=(EditText)findViewById(R.id.editText);
num=(int)(Math.random()*100001);
String cadena=String.valueOf(num);
Toast
notificacion=Toast.makeText(this,cadena,Toast.LE
NGTH_LONG);
notificacion.show();
}
public void controlar(View v) {
String
valorIngresado=et1.getText().toString();
int
valor=Integer.parseInt(valorIngresado);
if (valor==num) {
Toast
notificacion=Toast.makeText(this,"Muy bien
recordaste el número
mostrado.",Toast.LENGTH_LONG);
}

else {
Toast
notificacion=Toast.makeText(this,"Lo siento pero
no es el número que mostré.",Toast.LENGTH_LONG);
}
}
}
Analicemos el código fuente de la aplicación, lo primero es definir un objeto de
la clase EditText y una variable entera donde almacenaremos el valor aleatorio
que generamos y mostramos en un principio:
private int num;
En el método onCreate que es el primero que se ejecuta al inicializar la aplicación
es donde inicializamos la referencia del EditText:
Generamos un valor aleatorio comprendido entre 0 y 100000 y lo almacenamos
en la variable num:
num=(int)(Math.random()*100001);
Convertimos el valor entero a String ya que la clase Toast siempre hay que
pasarte un String para mostrar:
String cadena=String.valueOf(num);
Veamos ahora lo nuevo que es la clase Toast, tenemos que crear un objeto de
la clase Toast, para ello definimos una variable que la llamamos notificacion y
mediante el método estático makeText de la clase Toast creamos el objeto.
El método makeText tiene tres parámetros: el primero hace referencia a la
ventana o Activity donde aparece (this), el segundo el la variable de tipo String
que se mostrará en pantalla y por último es una constante que indica que la
notificación se mostrará por un tiempo largo o corto:
Toast
notificacion=Toast.makeText(this,cadena,Toast.LENGTH_LONG);
Finalmente cuando queremos que se muestre la notificación en pantalla
procedemos a llamar al método show de la clase Toast:
Esto hace que inmediatamente arranquemos la aplicación se mostrará la
notificación con el número que deberá memorizar el usuario:

Luego de unos segundos desaparece la notificación de pantalla (es decir en
nuestro programa desaparece de pantalla el número aleatorio)
Cuando el operador termina de cargar el número y procede a ejecutar el botón
"controlar" se procede a ejecutar el código que dispusimos en el método
"controlar":
public void controlar(View v) {
String valorIngresado=et1.getText().toString();
int valor=Integer.parseInt(valorIngresado);
if (valor==num) {
Toast notificacion=Toast.makeText(this,"Muy
bien recordaste el número mostrado.",Toast.LENGTH_LONG);
}
else {
Toast notificacion=Toast.makeText(this,"Lo
siento pero no es el número que mostré.",Toast.LENGTH_LONG);
}
}
En este método extraemos del control EditText el número que ingreso el usuario:
String valorIngresado=et1.getText().toString();
Lo convertimos a entero:
int valor=Integer.parseInt(valorIngresado);
Y mediante un if verificamos si coincide con el número aleatorio ingresado por el
operador, si coincide inmediatamente creamos una nueva notificación y
procedemos a mostrar que acertó:
if (valor==num) {
Toast notificacion=Toast.makeText(this,"Muy
bien recordaste el número mostrado.",Toast.LENGTH_LONG);
}
Por el falso mediante otra notificación mostramos que no ingresó correctamente
el número:
else {
Toast notificacion=Toast.makeText(this,"Lo
siento pero no es el número que mostré.",Toast.LENGTH_LONG);
}
10 - Control EditText
Desde el primer problema hemos estado utilizando el control que permite en
Android ingresar valores por teclado. La clase que administra la entrada de
cadenas de datos por teclade es EditText.
Pero en la palette de componentes vemos que hay muchos tipos de EditText:

Como podemos ver en la pestaña "Text Fields" se encuentran todos los tipos de
EditText que nos ofrece Android para utilizar en nuestras aplicaciones:
Password, E-mail, Number, etc.

Dependiendo del tipo de entrada de datos que necesitemos utilizaremos un tipo
específico de EditText.
Problema
Confeccionar una aplicación para android que permita ingresar el nombre de
usuario y su clave en dos controles de tipo EditText.
Verificar al presionar un botón si se ingresó algún texto en la clave. Si no se
ingresó texto informar mediante una notificación dicha situación.
(utilizar el método length() de la clase String para ver cuantos caracteres se
ingresaron.
La interfaz visual debe ser similar a esta:

Código fuente:

AppCompatActivity {
@Override
et2=(EditText)findViewById(R.id.editText2);
}
public void verificar(View v) {
String clave=et2.getText().toString();
if (clave.length()==0) {
Toast notificacion=
Toast.makeText(this,"La clave no puede quedar
vacía",Toast.LENGTH_LONG);
}
}
}
Como podemos ver cuando se presiona el botón "verificar" se procede a extraer
el contenido del EditText de la clave y mediante el método length() controlamos
si tiene cero caracteres, en caso afirmativo mostramos la notificación en pantalla:
public void verificar(View v) {
String clave=et2.getText().toString();
if (clave.length()==0) {
Toast notificacion= Toast.makeText(this,"La
clave no puede quedar vacía",Toast.LENGTH_LONG);
}
}
En pantalla tendremos un resultado similar a esto:

11 - Lanzar un segundo "Activity"
Hasta ahora todos los programas han tenido una sola ventana (Activity)
Es muy común que una aplicación tenga más de una ventana. Para implementar
esto en Android debemos plantear otros dos archivos uno xml con la interfaz y
otro java con la lógica (tengamos en cuenta que cuando utilizamos Android
Studio automáticamente cuando creamos un proyecto nos crea el archivo XML
y el código java del primer Activity)
Vamos a ver en este concepto los pasos que debemos dar para crear otro Activity
y como activarlo desde el Activity principal.

Problema:
Confeccionar un programa que muestre en la ventana principal un botón que al
ser presionado muestre otra ventana (Activity) mostrando un TextView con el
nombre del programador de la aplicación y un botón para cerrar la ventana o
actividad y que vuelva al primer Activity.
1 - Primero creamos un nuevo proyecto que lo llamaremos Proyecto010 y en la
ventana principal creamos la siguiente interfaz:
Es decir que nosotros queremos que cuando se presione el botón "ACERCADE"
nos abra otra ventana (Activity) y nos muestre el nombre del programador y un
botón para cerrar dicha ventana.

2 - Ahora tenemos que crear el segundo Activity. Para esto hacemos clic con el
botón derecho del mouse en la ventana de Project donde dice "app" y
seleccionamos New -> Activity -> Empty Activity
Aparece un diálogo donde debemos definir el nombre del Activity "Activity Name"
y le asignaremos como nombre "AcercaDe" (se crearán dos archivos
AcercaDe.java y activity_acerca_de.xml):

Ya tenemos los cuatro archivos necesarios para implementar la aplicación:

Los dos primeros que se crean cuando iniciamos el proyecto:
activity_main.xml

MainActivity.java
Y estos dos nuevos archivos para la segundo ventana:
activity_acerca_de.xml
AcercaDe.java
Implementamos la interfaz visual del segundo Activity es decir del archivo
activity_acerca_de.xml con los siguientes controles:

3 - Ahora implementaremos la funcionalidad en la actividad (Activity) principal
para que se active la segunda ventana.

Inicializamos la propiedad onClick del objeto de la clase Button con el valor
"acercade", este es el método que se ejecutará cuando se presione.
El código fuente de la actividad principal queda:
import android.content.Intent;
AppCompatActivity {
@Override
}
public void acercade(View view) {
Intent i = new Intent(this,
AcercaDe.class );
startActivity(i);
}
}
En el método acercade creamos un objeto de la clase Intent y le pasamos como
parámetros la referencia del objeto de esta clase (this) y la referencia del otro
Activity (AcercaDe.class)
Llamamos posteriormente al método startActivity pasando el objeto de la clase
Intent (con esto ya tenemos en pantalla la ventana del segundo Activity):
public void acercade(View view) {
Intent i = new Intent(this, AcercaDe.class );
startActivity(i);
}
Si ejecutamos el programa podemos ver que cuando presionamos el botón
"Acerca De" aparece la segunda ventana donde se muestra el TextView con el
valor "Autor : Rodriguez Pablo" y un botón con el texto "salir" (si presionamos
este botón no sucede nada, esto debido a que no hemos asociadoningún evento
a dicho botón)
4 - Debemos codificar el evento onClick de la segunda actividad. Seleccionemos
el botón "salir" y definamos en la propiedad onClick el nombre de método que se
ejecutará al presionarse el botón (en nuestro caso lo llamaremos "salir") :
El código fuente de la actividad AcercaDe queda:

public class AcercaDe extends AppCompatActivity
{
@Override
setContentView(R.layout.activity_acerca_de);
}
public void salir(View v) {
finish();
}
}
Cuando se presiona el botón salir se ejecuta el método "salir" llamando al método
finish() que tiene por objetivo liberar el espacio de memoria de esta actividad y
pedir que se active la actividad anterior.
Ahora nuestro programa está funcionando completamente:
Primer Activity:

Problema propuesto
1. Realizar un programa que contenga dos Activity. En el primero que solicite el
ingreso de una clave (control Password) Si ingresa la clave "abc123" activar el
segundo Activity mostrando en un TextView un mensaje de bienvenida (mostrar
en Toast si se ingresa la clave incorrecta en el primer Activity).
Llamar al proyecto: Proyecto011.
En tiempo de ejecución los dos Activity deben mostrarse algo similar a esto:

12 - Lanzar un segundo "Activity" y
pasar parámetros
Hemos visto en el concepto anterior que un programa puede tener más de una
ventana representando cada ventana con una clase que hereda de
AppCompatActivity.
Una situación muy común es que la primer ventana necesite enviar datos a la
segunda para que a partir de estos proceda a efectuar una acción.
Problema:
Confeccionar un programa que solicite el ingrese de una dirección de un sitio
web y seguidamente abrir una segunda ventana que muestre dicha página.

Para resolver este problema utilizaremos el control visual WebView que nos
permite mostrar el contenido de un sitio web.
Crearemos un nuevo proyecto llamado proyecto012.
1 - Nuestro primer Activity tendrá la siguiente interfaz visual (ver controles):
Tenemos un control de tipo TextView , otro de tipo EditText y finalmente otro de

tipo Button (inicializar la propiedad onClick con el nombre de método llamado
"ver").
El código fuente de esta Activity es:
import android.content.Intent;
AppCompatActivity {
@Override
}
public void ver (View v) {
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
método putExtra de la clase Intent. Tiene dos parámetros de tipo String, en el
primero indicamos el nombre del dato y en el segundo el valor del dato:
public void ver(View v) {
Intent i=new Intent(this,Actividad2.class);
i.putExtra("direccion", et1.getText().toString());
startActivity(i);
}
La segunda interfaz visual (recordemos que debemos presionar el botón derecho
en la ventana Project (sobre app) y seleccionar la opción New -> Activity ->
Emplty Activity:

En el diálogo que aparece especificamos el nombre de nuestra segundo Activity
y lo llamaremos Actividad2:

Codificamos la funcionalidad de la segunda actividad
import android.webkit.WebView;
public class Actividad2 extends
AppCompatActivity {
WebView webView1;

@Override
setContentView(R.layout.activity_actividad2);
webView1=(WebView)findViewById(R.id.webView);
Bundle bundle = getIntent().getExtras();
String
dato=bundle.getString("direccion");
webView1.loadUrl("http://" + dato);
}
public void finalizar(View v) {
finish();
}
}
En esta clase definimos una variable de tipo Bundle y la inicializamos llamando
al método getExtras() de la clase Intent (esto lo hacemos para recuperar el o los
parámetros que envió la otra actividad (Activity)):
Bundle bundle = getIntent().getExtras();
String dato=bundle.getString("direccion");
webView1.loadUrl("http://" + dato);
El método loadUrl de la clase WebView permite visualizar el contenido de un sitio
web.
Importante
Como nuestra aplicación debe acceder a internet debemos hacer una
configuración en el archivo "AndroidManifest.xml", podemos ubicar este archivo:

Agregamos el permiso tipeando lo siguiente en este archivo:
<uses-permission android:name="android.permission.INTERNET"
/>
Luego el archivo AndroidManifest.xml queda con el permiso agregado:

Ahora nuestro programa debería estar funcionando completamente.
La primer ventana debería ser algo similar a esto:

La segunda ventana debería ser algo similar a esto otro:

13 - Almacenamiento de datos
mediante la clase SharedPreferences
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 o
cierra la aplicación)
Según el tipo de necesidades utilizaremos alguno de estos métodos:
1. Mediante la clase SharedPreferences.
2. Mediante archivos de Texto.
3. En una base de datos con acceso a SQL.

No será raro que una aplicación utilice más de uno de estos métodos 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 aplicación
como pueden ser colores de pantalla, nivel actual en un juego, datos iniciales de
controles de entrada de dato etc.
Problema 1:
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 aplicación almacenar en el control EditText el último mail ingresado.
Disponer un botón para almacenar el mail ingresado y finalizar el programa.
Crearemos un nuevo proyecto llamado proyecto013.
La interfaz visual a implementar es:

Disponemos un TextView la propiedad Text con "Ingrese el
mail:".
Disponemos un EditText
Disponemos un Button su propiedad Text con el valor
confirmar
su propiedad onClic con el valor
ejecutar
El código java es:
import android.content.Context;
import android.content.SharedPreferences;
AppCompatActivity {
@Override
SharedPreferences
prefe=getSharedPreferences("datos",
Context.MODE_PRIVATE);
et1.setText(prefe.getString("mail",""));
}
public void ejecutar(View v) {
SharedPreferences
preferencias=getSharedPreferences("datos",Contex
t.MODE_PRIVATE);
SharedPreferences.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 través
del método getSharedPreferences. El primer parámetro es el nombre del archivo
de preferencias y el segundo la forma de creación del archivo (MODE_PRIVATE
indica que solo esta aplicación 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 lógico no existe el archivo de preferencias lo que hace que Android lo
cree, si tratamos de extraer el valor de mail retornará el segundo parámetro es
decir el String con una cadena vacía:
et1.setText(prefe.getString("mail",""));
Cuando se presiona el botón "Confirmar" lo que hacemos es grabar en el archivo
de preferencias el contenido del EditText en una variable llamada "mail":
public void ejecutar(View v) {
SharedPreferences
preferencias=getSharedPreferences("datos",Context.MODE_PRIV
ATE);
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 método
putString almacenamos en mail el valor del String cargado en el EditText. Luego
debemos llamar al método 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 aplicación se recupere el último mail ingresado.
Recordemos que el método finish de la clase Activity finaliza la actividad actual
(como tenemos una aplicación con una sola actividad finalizará completamente
nuestro programa.
Comentarios extras.
El modo de operación del archivo puede ser:

MODE_PRIVATE solo la aplicación 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 según el método 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 también que tipo de datos extraemos:
int e=prefe.getInt("edad", 0);
boolean acti=prefe.getBoolean("activo", false);
float alt=prefe.getFloat("altura", 0f);
Problema 2:
Confeccionar un programa que permita administrar una agenda personal.
Nuestra clave será el nombre de la persona. La interfaz visual a implementar
será similar a esta:

import android.content.SharedPreferences;
AppCompatActivity {
@Override
}
public void grabar(View v) {
String nombre=et1.getText().toString();
String datos=et2.getText().toString();
SharedPreferences
preferencias=getSharedPreferences("agenda",
editor.putString(nombre, datos);
editor.commit();
Toast.makeText(this,"Datos grabados",
Toast.LENGTH_LONG).show();
}
public void recuperar(View v) {

SharedPreferences
prefe=getSharedPreferences("agenda",
String d=prefe.getString(nombre, "");
if (d.length()==0) {
Toast.makeText(this,"No existe dicho
nombre en la agenda",Toast.LENGTH_LONG).show();
}
else {
et2.setText(d);
}
}
}
Definimos dos objetos de la clase EditText donde se ingresan el nombre de la
persona y los datos de dicha persona:
Cuando se presiona el botón grabar:
String datos=et2.getText().toString();
SharedPreferences
preferencias=getSharedPreferences("agenda",
editor.commit();
Toast.makeText(this,"Datos
grabados",Toast.LENGTH_LONG).show();
}
Extraemos los dos datos de los EditText, creamos un objeto de la clas
SharedPReferences con el nombre de "agenda".
Creamos un objeto de la clase Editor y procedemos a grabar en el archivo de
preferencias mediante putString:
Significa que en el archivo de preferencias se almacena una entrada con el
nombre de la persona y los datos de dicha persona.
Por otro lado tenemos la lógica para recuperar los datos de una persona de la
agenda:
SharedPreferences
prefe=getSharedPreferences("agenda", Context.MODE_PRIVATE);
String d=prefe.getString(nombre, "");
if (d.length()==0) {
Toast.makeText(this,"No existe dicho nombre en
la agenda",Toast.LENGTH_LONG).show();

}
else {
et2.setText(d);
}
}
Abrimos el archivo de preferencias y llamamos al método getString buscando el
nombre ingresado en el et1. En el caso que lo encuentre retorna el dato asociado
a dicha clave.
En el emulador podemos ver como ingresamos y recuperamos datos de la
agenda:
Android Device Monitor

Veamos una herramienta para poder entre otras cosas acceder al sistema de
archivos del emulador de Android.
Vamos a arrancar el "Android Device Monitor", lo podemos ubicar en el menú de
opciones:
Mediante este programa vamos a acceder al "File Explorer" del emulador para
localizar el archivo de preferencias donde se ha guardado la agenda.
Seleccionamos la pestaña "File Explorer" y luego navegamos hasta la carpeta
que contiene los datos de la aplicación, podemos ver que hay un archivo llamado
agenda.xml (siempre y cuando ya hayamos ejecutado la aplicación y cargado
datos):

Podemos extraer este archivo del dispositivo para analizarlo, para ello
presionamos el ícono de la parte superior derecha estando seleccionado el
archivo agenda.xml:

Luego podemos utilizar cualquier editor de texto para ver el contenido del archivo
agenda.xml y veremos que tiene algo similar a esto (depende que datos usted
cargó):

Como podemos ver el archivo xml tiene una marca map y dentro un conjunto de
marcas string donde define una propiedad llamada name donde se almacena el
nombre de la persona y en el interior de la marca sus datos.
La clase SharedPreferences se utiliza siempre que tenemos que almacenar un
valor como clave (en este caso el nombre de la persona) y los datos asociados
a dicha clave.
Problema propuesto
1. Realizar un programa que genere un número aleatorio entre 1 y 50, pedir que el
operador lo adivine, informar si ganó o si el número es mayor o menor al
ingresado. Cuando el operador lo adivine incrementaren uno el puntaje de juego.
Cada vez que se ingrese a la aplicación mostrar el puntaje actual, es decir
recordar el puntaje en un archivo de preferencias.
La interfaz visual de la aplicación a desarrollar es:

14 - Almacenamiento de datos en un
archivo de texto en la memoria
interna
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 1:
Confeccionar un programa que permita almacenar notas en un control EditText
y cuando se presione un botón 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 Android Studio y definir como nombre: proyecto016.
Para crear la interfaz visual primero disponemos un botón alineado en la parte
inferior del celular y luego de la pestaña "Text Fields" seleccionamos un objeto
de la clase EditText ("Multiline Text") y lo disponemos en la parte superior de la
pantalla e inicializamos la propiedad background del EditText con el valor #ffff00
(que corresponde con el color amarillo):
Finalmente procedemos a redimensionar el EditText por medio del mouse y
configuramos la propiedad gravity tildando los valores top y left para que los
datos que ingresa el operador aparezcan en la parte superior izquierda y no
centrados:

El código fuente de la aplicación:
import android.app.Activity;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
AppCompatActivity {
@Override
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) {
}
}

private boolean existe(String[] archivos,
String archbusca) {
for (int f = 0; f < archivos.length;
f++)
if (archbusca.equals(archivos[f]))
return true;
return false;
}
try {
OutputStreamWriter archivo = new
OutputStreamWriter(openFileOutput(
"notas.txt",
Activity.MODE_PRIVATE));
archivo.write(et1.getText().toString());
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 método grabar que se ejecuta cuando presionamos el botón "grabar"
(recordemos de inicializar la propiedad "onClick" del botón con el valor "grabar"):
try {
OutputStreamWriter(openFileOutput("notas.txt",Activity.MODE
_PRIVATE));
Creamos un objeto de la clase OutputStreamWriter y al constructor de dicha
clase le enviamos el dato que retorna el método openFileOutput propio de la
clase ActionBarActivity que le pasamos como parámetro el nombre del archivo
de texto y el modo de apertura.

Seguidamente si el archivo se creó correctamente procedemos a llamar al
método write y le pasamos el String a grabar, en este caso extraemos los datos
del EditText:
Luego de grabar con el método write llamamos al método 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 algún 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 método makeText de la clase
Toast y le pasamos la referencia del ActionBarActivity actual, el String a mostrar
y el tiempo de duración del mensaje. Con el objeto devuelto por el método
makeText procedemos a llamar seguidamente al método show para que se
muestre el mensaje.
Es común llamar al método show de la clase Toast en una sola línea como esta:
Toast.makeText(this,"Los datos fueron grabados",
Toast.LENGTH_SHORT).show();
El método 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 método que verifica si en el vector de tipo String existe el archivo
"notas.txt":
if (existe(archivos,"notas.txt"))
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 método 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
Leemos la primer línea del archivo de texto:
String linea=br.readLine();
Inicializamos un String vacío:
String todo="";
Mientras el método readLine de la clase BufferedReader devuelva un String:
while (linea!=null)
{
Lo concatenamos al String junto a un salto de línea:

todo=todo+linea+"n";
Leemos la próxima línea:
linea=br.readLine();
}
Llamamos al método 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 método 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;
}
Luego de ejecutar el programa podemos entrar al "Android Device Monitor"
(podemos ejecutarlo desde el menú del Android Studio: Tools->Android-
>Android Device Monitor) y localizar en el dispositivo donde se guarda el archivo
de texto creado:

Como vemos se crea una carpeta llamada "files" que contiene el archivo creado
(si creamos más archivos de texto se almacenarán en esta carpeta)
Problema 2:
Confeccionar un programa para administrar un calendario de actividades diarias.
Los nombres de archivos corresponderán a las fechas que ingresamos. Luego
cuando consultamos una fecha verificamos si hay un archivo de texto que
coincida con dicha fecha.
La interfaz visual a crear será la siguiente:

Es decir disponemos un "Medium Text" donde dice fecha. Un EditText de tipo
"Date" donde se carga la fecha. Luego otro EditText de tipo "Multiline Text" y
finalmente un botón.
El código fuente de la aplicación:
import android.app.Activity;

AppCompatActivity {
@Override
}
String
nomarchivo=et1.getText().toString();
nomarchivo=nomarchivo.replace('/','-');
try {
nomarchivo,
archivo.flush();
archivo.close();
}

Toast t = Toast.makeText(this, "Los
datos fueron grabados",
Toast.LENGTH_SHORT);
t.show();
et1.setText("");
et2.setText("");
}
String
nomarchivo=et1.getText().toString();
boolean enco=false;
for (int f = 0; f < archivos.length;
f++)
if (nomarchivo.equals(archivos[f]))
enco= true;
if (enco==true) {
try {
InputStreamReader(
openFileInput(nomarchivo));
String todo = "";
}
br.close();
archivo.close();
et2.setText(todo);
}
} else
{
Toast.makeText(this,"No hay datos
grabados para dicha
fecha",Toast.LENGTH_LONG).show();

et2.setText("");
}
}
}
El método grabar que se ejecuta cuando presionamos el botón grabar (no olvidar
de inicializar la propiedad onClick de cada botón con el nombre del método
respectivo) tenemos primero que extraer la fecha ingresada en el primer EditText
y remplazar las barras de la fecha por guiones ya que no se puede utilizar este
caracter dentro de un nombre de archivo en Android:
String nomarchivo=et1.getText().toString();
Creamos un objeto de la clase OutputStreamWriter y al constructor de dicha
clase le enviamos el dato que retorna el método openFileOutput propio de la
clase ActionBarActivity que le pasamos como parámetro el nombre del archivo
de texto y el modo de apertura.
try {
nomarchivo,
Seguidamente si el archivo se creó correctamente procedemos a llamar al
método write y le pasamos el String a grabar, en este caso extraemos los datos
del EditText:
Luego de grabar con el método write llamamos al método flush para que vuelque
todos los datos que pueden haber quedado en el buffer y procedemos al cerrado
del archivo:
archivo.flush();
archivo.close();
Cada vez que se graba un dato se genera un archivo de texto para dicha fecha,
si ya había un archivo con el mismo nombre (es decir la misma fecha) se pisa el
anterior.
Desde el "Android Device Monitor" podemos observar todos los archivos de texto
que se van creando a medida que registramos actividades en la aplicación que
desarrollamos:

Para recuperar los datos de una determinada fecha se ejecuta el método
"recuperar":
boolean enco=false;
for (int f = 0; f < archivos.length; f++)
enco= true;
if (enco==true) {
try {
InputStreamReader(
String todo = "";
}
br.close();
archivo.close();
et2.setText(todo);
}
} else
{
Toast.makeText(this,"No hay datos grabados para
dicha fecha",Toast.LENGTH_LONG).show();
et2.setText("");
}
}
Lo primero que hacemos es recuperar del EditText la fecha que ingresó el
operador para buscar:
Remplazamos las barras por guiones (recordemos que grabamos guiones en la
carga ya que la barra de una fecha no es un caracter válido en un archivo en
Android):
Obtenemos la lista de todos los archivos que almacena la aplicación mediante la
llamada al método fileList():
Mediante un for recorremos el vector con los nombres de archivos y los
comparamos con la fecha ingresada, en el caso de encontrarlo procedemos a
cambiar el estado de una bandera:
for (int f = 0; f < archivos.length; f++)

enco= true;
Si la bandera está en true significa que existe el archivo por lo que procedemos
a abrirlo, leerlo y cargar el et2 con los datos del archivo:
if (enco==true) {
try {
InputStreamReader(
String todo = "";
}
br.close();
archivo.close();
et2.setText(todo);
}
La interfaz visual en tiempo de ejecución debe ser similar a esta:

15 - Almacenamiento de datos en un
archivo de texto localizado en una
tarjeta SD
En el concepto anterior vimos como crear y leer un archivo de texto en la
memoria interna del equipo Android. En algunas situaciones podría ser útil
almacenar los datos en una tarjeta SD (tener en cuenta que no todos los

dispositivos Android cuentan con esta característica), 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 botón. Disponer
un segundo botón 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:

Podemos ver en la ventana "Component Tree" que la interfaz contiene dos
TextView, dos EditText y dos Button.
No olvidar inicializar las propiedades onClick de cada botón con los nombres de
métodos "grabar" y "recuperar".
El primer paso es modificar el archivo AndroidManifest.xml para permitir el
acceso a la tarjeta SD desde nuestra aplicación esto lo hacemos desde el editor
de texto del Android Studio
En la carpeta app/manifests podemos abrir el archivo "AndroidManifest.xml" y
agregar la línea de permiso de acceso a la memoria externa del dispositivo:
Tenemos que agregar el permiso siguiente:
<uses-permission
android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
Tener cuidado que debe estar fuera del elemento application pero dentro del
elemento manifest:
<?xml version="1.0" encoding="utf-8"?>
<manifest
xmlns:android="http://schemas.android.com/apk/res/android"
package="ar.com.tutorialesya.proyecto018">
<uses-permission
android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<application
android:allowBackup="true"

android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:supportsRtl="true"
android:theme="@style/AppTheme">
<activity android:name=".MainActivity">
<intent-filter>
<action
android:name="android.intent.action.MAIN" />
<category
android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>
El código fuente es:
import android.os.Environment;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
AppCompatActivity {
@Override

}
String nomarchivo =
et1.getText().toString();
String contenido =
try {
File tarjeta =
Environment.getExternalStorageDirectory();
Toast.makeText(this,tarjeta.getAbsolutePath(),To
ast.LENGTH_LONG).show();
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",
et1.setText("");
et2.setText("");
} catch (IOException ioe) {
Toast.makeText(this, "No se pudo
grabar",
}
}
String nomarchivo =
File tarjeta =

File file = new
File(tarjeta.getAbsolutePath(), nomarchivo);
try {
FileInputStream fIn = new
FileInputStream(file);
InputStreamReader(fIn);
String todo = "";
todo = todo + linea + " ";
}
br.close();
archivo.close();
et2.setText(todo);
Toast.makeText(this, "No se pudo
leer",
}
}
}
El método para grabar los datos en un archivo de texto localizado en una tarjeta
SD comienza obteniendo el directorio raiz de la tarjeta a través del método
getExternalStorageDirectory(), el mismo retorna un objeto de la clase File.
String nomarchivo = et1.getText().toString();
String contenido=et2.getText().toString();
try
{
File tarjeta =
Creamos un nuevo objeto de la clase File indicando el camino de la unidad SD y
el nombre del archivo a crear:
File file = new File(tarjeta.getAbsolutePath(),
nomarchivo);
Por último similar al acceso de un archivo interno creamos un objeto de la clase
OutputStreamWriter:
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)
{
Toast.makeText(this, "No se pudo grabar",
}
}
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:
String nomarchivo = et1.getText().toString();
File tarjeta =
File file = new File(tarjeta.getAbsolutePath(),
nomarchivo);
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)
{
Toast.makeText(this, "No se pudo leer",
}
}
Importante.

Si lo probamos con el emulador del Nexus 5 en el Android Studio cuando
tratemos de grabar nos mostrará la notificación "No se pudo grabar", esto debido
a que dicho celular no permite extender la memoria mediante tarjetas sd.
La solución para probar es crear otro dispositivo virtual. Los pasos para crear
otro dispositivo virtual en Android Studio son los siguientes:
1. Desde el menú de opciones del Android Studio accedemos a Tools-
>Android->AVD Manager.
2. Aparece un diálogo con todas las máquinas virtuales creadas hasta el
momento (en las primeras versiones de Android Studio crea una máquina
virtual para el Nexus 5)

Presionamos el botón "Create Virtual Device".
3. En este nuevo diálogo debemos seleccionar que crearemos un dispositivo
virtual de tipo "Phone" y por ejemplo elegiremos uno genérico de 5.1
pulgadas:

4. El siguiente diálogo seleccionamos la imagen de máquina virtual que
disponemos:

5. En el nuevo diálogo asignamos un nombre al AVD, por ejemplo:
Android480x800:

6. Presionamos el botón "Show Advanced Settings"
Controlamos que tenga configurado la propiedad de SD card con un valor
de 100 o más:

Finalmente ya tenemos configurado nuestra nueva máquina virtual que
permite almacenar datos en una tarjeta sd.
Cuando ejecutemos nuevamente un proyecto tenemos que seleccionar
esta nueva máquina virtual para que arranque:

Ubicación de los archivos desde el Android Device Monitor.
Si luego de ejecutar la aplicación y almacenar un par de archivos de texto
queremos ver donde se almacenan en nuestro dispositivo virtual podemos
inicializar el "Android Device Monitor" desde el menú del Android Studio Tools-
>Android->Android Device Monitor:

Como podemos ver se almacenan en una carpeta que no tiene nada que ver con
la carpeta donde se almacenan los archivos de texto internos.
16 - 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 pequeños, como Android.
Las ventajas que presenta utilizar SQLite es que no requiere configuración, no
tiene un servidor de base de datos ejecutándose en un proceso separado y es
relativamente simple su empleo.
Problema:
Confeccionar un programa que permita almacenar los datos de articulos. Crear
la tabla articulos y definir los campos codigo, descripción del articulo y precio.
El programa debe permitir:
1 - Carga de articulo.
2 - Consulta por el codigo.
3 - Consulta por la descripción.
4 - Borrado de un articulo ingresando su código.
4 - Modificación de la descripción y el precio.
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.
Para crear una nueva clase desde Android Studio procedemos a presionar el
botón derecho del mouse sobre la carpeta que contienen todos los archivo java
del proyecto y seleccionamos New - > Java Class:

En este diálogo ingresamos el nombre de nuestra clase, en nuestro ejemplo la
llamaremos AdminSQLiteOpenHelper:
Ya tenemos un nuevo archivo en nuestro proyecto:

Ahora tenemos que codificar esta clase que tiene por objetivo administrar la base
de datos que crearemos. Primero hacemos que nuestra clase herede de la clase
SQLiteOpenHelper:
import android.database.sqlite.SQLiteOpenHelper;
/**
* Created by diego on 16/04/2016.
*/
public class AdminSQLiteOpenHelper extends SQLiteOpenHelper{
}
La clase SQLiteOpenHelper requiere que se implementen dos métodos
obligatoriamente onCreate y onUpgrade, podemos hacer que el Android Studio
nos ayude en su codificación así no tenemos que tipearlos nosotros:
presionamos la teclas "ALT" y "ENTER" teniendo el cursor sobre el nombre de
la clase "AdminSQLiteOpenHelper" y nos aparece un menú donde
seleccionamos "Implement Methods" y luego un diálogo donde seleccionamos
los métodos a implementar:

Ya tenemos la clase con los dos métodos:
import android.database.sqlite.SQLiteDatabase;
/**
*/
public class AdminSQLiteOpenHelper extends SQLiteOpenHelper{
@Override
public void onCreate(SQLiteDatabase db) {
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion,
int newVersion) {
}
}
Pero todavía nos marca un error ya que la clase padre SQLiteOpenHelper
implementa constructores que tienen parámetros, entonces tenemos que definir
el constructor en esta clase, para ello estando el cursor sobre el nombre de la
clase "AdminSQLiteOpenHelper" presionamos nuevamente las teclas "ALT" y
"Enter" y en el menú contectual que aparece seleccionamos "Create constructor
matching super". Aparece un diálogo con todos los constructores que
implementa la clase padre (seleccionammos el que tiene tres parámetros):

Ahora la clase no muestra ningún error y pasaremos a implementar la creación
de la tabla articulos dentro del método onCreate:
/**
*/
public class AdminSQLiteOpenHelper extends
SQLiteOpenHelper{
public AdminSQLiteOpenHelper(Context
context, String name,
SQLiteDatabase.CursorFactory factory, int
version) {
super(context, name, factory, version);
}
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL("create table
articulos(codigo int primary key,descripcion
text,precio real)");
}
@Override
public void onUpgrade(SQLiteDatabase db, int
oldVersion, int newVersion) {
}
}
Hemos codificado en el método onCreate la creación de la tabla articulos con los
campos codigo (que es entero y clave primaria), descripcion que es de tipo texto
y precio es un valor real. El método onCreate se ejecutará una única vez
(Eventualmente si uno quiere modificar la estructura de la tabla debemos hacerlo
en el método onUpgrade).
Ahora implementemos la interfaz visual para resolver nuestro problema.
Debemos crear en nuestro archivo activity_main.xml la siguiente interfaz:

Como vemos disponemos tres TextView, tres EditText y cinco Button.
El código fuente de nuestro Activity es el siguiente:

import android.content.ContentValues;
import android.database.Cursor;
AppCompatActivity {
private EditText et1,et2,et3;
@Override
}
public void alta(View v) {
AdminSQLiteOpenHelper admin = new
AdminSQLiteOpenHelper(this,
"administracion", null, 1);
SQLiteDatabase bd =
admin.getWritableDatabase();
String cod = et1.getText().toString();
String descri =
String pre = et3.getText().toString();
ContentValues registro = new
ContentValues();
registro.put("codigo", cod);
registro.put("descripcion", descri);

registro.put("precio", pre);
bd.insert("articulos", null, registro);
bd.close();
et1.setText("");
et2.setText("");
et3.setText("");
Toast.makeText(this, "Se cargaron los
datos del artículo",
}
public void consultaporcodigo(View v) {
SQLiteDatabase bd =
Cursor fila = bd.rawQuery(
"select descripcion,precio from
articulos where codigo=" + cod, null);
if (fila.moveToFirst()) {
et2.setText(fila.getString(0));
} else
Toast.makeText(this, "No existe un
artículo con dicho código",
bd.close();
}
public void consultapordescripcion(View v) {
SQLiteDatabase bd =
String descri =

"select codigo,precio from
articulos where descripcion='" + descri +"'",
null);
} else
artículo con dicha descripción",
bd.close();
}
public void bajaporcodigo(View v) {
SQLiteDatabase bd =
String cod= et1.getText().toString();
int cant = bd.delete("articulos",
"codigo=" + cod, null);
bd.close();
et1.setText("");
et2.setText("");
et3.setText("");
if (cant == 1)
Toast.makeText(this, "Se borró el
else
}
public void modificacion(View v) {
SQLiteDatabase bd =

String descri =
ContentValues registro = new
ContentValues();
int cant = bd.update("articulos",
registro, "codigo=" + cod, null);
bd.close();
if (cant == 1)
Toast.makeText(this, "se modificaron
los datos", Toast.LENGTH_SHORT)
.show();
else
Toast.makeText(this, "no existe un
artículo con el código ingresado",
}
}
Recordar de inicializar la propiedad onClick de cada botón para enlazarlo con el
método respectivo:
"alta","consultaporcodigo","consultapordescripcion","bajaporcodigo" y
"modificacion".
1 - Alta de datos.
Cuando se presiona el botón "ALTA" se ejecuta el método "alta" recordemos
inicializar la propiedad "onClick" del botón desde la ventana de visualización del
archivo XML.
Lo primero que hacemos en este método 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
versión 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 método 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 método
getWritableDatabase (la base de datos se abre en modo lectura y escritura).
Creamos un objeto de la clase ContentValues y mediante el método put
inicializamos todos tos campos a cargar.
Seguidamente llamamos al método insert de la clase SQLiteDatabase pasando
en el primer parámetro el nombre de la tabla, como segundo parámetro un null y
por último el objeto de la clase ContentValues ya inicializado (este método es el

que provoca que se inserte una nueva fila en la tabla articulos 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) {
SQLiteDatabase bd = admin.getWritableDatabase();
String descri = et2.getText().toString();
ContentValues registro = new ContentValues();
bd.insert("articulos", null, registro);
bd.close();
et1.setText("");
et2.setText("");
et3.setText("");
Toast.makeText(this, "Se cargaron los datos del
artículo",
}
2 - Consulta de articulo por código.
Cuando se presiona el botón "CONSULTA POR CODIGO" se ejecuta el método
consultaporcodigo:
public void consultaporcodigo(View v) {
"select descripcion,precio from articulos
where codigo=" + cod, null);
} else
Toast.makeText(this, "No existe un artículo con
dicho código",
bd.close();
}
En el método consultaporcodigo lo primero que hacemos es crear un objeto de
la clase AdminSQLiteOpenHelper y obtener una referencia de la base de datos
llamando al método getWritableDatabase.
Seguidamente definimos una variable de la clase Cursor y la inicializamos con el
valor devuelto por el método llamado rawQuery.

La clase Cursos almacena en este caso una fila o cero filas (una en caso que
hayamos ingresado un codigo existente en la tabla articulos), llamamos al
método moveToFirst() de la clase Cursos y retorna true en caso de existir un
articulo con el codigo ingresado, en caso contrario retorna cero.
Para recuperar los datos propiamente dichos que queremos consultar llamamos
al método getString y le pasamos la posición del campo a recuperar (comienza
a numerarse en cero, en este ejemplo la columna cero representa el campo
descripcion y la columna 1 representa el campo precio)
3 - Consulta de articulo por descripción.
Cuando se presiona el botón "CONSULTA POR DESCRIPCION" se ejecuta el
método consultapordescripcion:
public void consultapordescripcion(View v) {
"select codigo,precio from articulos where
descripcion='" + descri +"'", null);
} else
Toast.makeText(this, "No existe un artículo con
dicha descripción",
bd.close();
}
En el método consultapordescripcion lo primero que hacemos es crear un objeto
de la clase AdminSQLiteOpenHelper y obtener una referencia de la base de
datos llamando al método getWritableDatabase.
Seguidamente definimos una variable de la clase Cursor y la inicializamos con el
valor devuelto por el método llamado rawQuery.
Es importante notar en el where de la clausula SQL hemos dispuesto comillas
simples entre el contenido de la variable descri:
"select codigo,precio from articulos where
descripcion='" + descri +"'", null);
Esto es obligatorio para los campos de tipo text (en este caso descripcion es de
tipo text)
4 - Baja o borrado de datos.
Para borrar uno o más registros la clase SQLiteDatabase tiene un método que
le pasamos en el primer parámetro el nombre de la tabla y en el segundo la
condición que debe cumplirse para que se borre la fila de la tabla. El método
delete retorna un entero que indica la cantidad de registros borrados:
public void bajaporcodigo(View v) {
SQLiteDatabase bd =

String cod= et1.getText().toString();
int cant = bd.delete("articulos", "codigo=" +
cod, null);
bd.close();
et1.setText("");
et2.setText("");
et3.setText("");
if (cant == 1)
Toast.makeText(this, "Se borró el artículo
con dicho código",
else
Toast.makeText(this, "No existe un artículo
con dicho código",
}
5 - Modificación de datos.
En la modificación de datos debemos crear un objeto de la clase ContentValues
y mediante el método put almacenar los valores para cada campo que será
modificado. Luego se llama al método update de la clase SQLiteDatabase
pasando el nombre de la tabla, el objeto de la clase ContentValues y la condición
del where (el cuanto parámetro en este ejemplo no se lo emplea)
public void modificacion(View v) {
ContentValues registro = new ContentValues();
int cant = bd.update("articulos", registro,
"codigo=" + cod, null);
bd.close();
if (cant == 1)
Toast.makeText(this, "se modificaron los datos",
Toast.LENGTH_SHORT)
.show();
else
Toast.makeText(this, "no existe un artículo con
el código ingresado",
}
Ubicación de la base de datos en el dispositivo

Para conocer donde se almacena físicamente la base de datos en el dispositivo
podemos abrir el programa "Android Device Monitor" desde el menú del Android
Studio Tools->Android->Android Device Monitor:

17 - Instalación del programa
Android en un dispositivo real
Normalmente uno cuando desarrolla aplicaciones en Android hace toda la
programación, depuración y pruebas en un dispositivo virtual en la pc.
Ahora vamos a ver los pasos para probar la aplicación en un dispositivo Android
real.
La primera forma que veremos de probar nuestra aplicación es copiar el archivo
con extensión APK a nuestro dispositivo.
1. Primero en el ícono de configuración de nuestro teléfono o tablet android
seleccionamos la opción "Aplicaciones" -> y marcamos la opción "Origen
desconocido (Permitir la instalación de aplicaciones no pertenecientes al
mercado)"
2. Desde nuestro equipo de escritorio enviamos un mail a nuestro celular
adjuntando el archivo con extensión apk que se encuentra en el directorio
app/build/outputs/apk de nuestro proyecto.
3. Abramos el mail desde nuestro celular y seleccionemos el archivo adjunto.
Confirmamos que queremos instalarlo.

Ya podemos probar nuestra aplicación:

18 - Layout (LinearLayout)
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 diseños más simples y más empleado. Simplemente
establece los componentes visuales uno junto al otro, ya sea horizontal o
verticalmente.
Creemos un proyecto llamado Proyecto020, borremos el TextView que agrega
por defecto el Android Studio.
De la "Palette" de componentes de Android Studio arrastraremos de la pestaña
"Layouts" el objeto de la clase "Linear Layout (Vertical)":

Ahora podemos ver que sucede cuando disponemos cinco botones dentro del
contenedor LinearLayout (Todos los botones se disponen obligatoriamente uno
debajo del otro y no hay posibilidad de ubicarlos con el mouse):

El primer cambio que podemos hacer a esta tipo de Layout es cambiar la
propiedad "orientation" por el valor horizontal (esto hace que los botones se
dispongan uno al lado del otro y no hay posibilidad de disponer controles uno
debajo de otro)
Hay que tener en cuenta que si los controles no entran en pantalla los mismos
no se ven y si son botones como en este caso es imposible hacer clic sobre los
mismos:

Tengamos en cuenta que en la "Palette" de Android Studio aparecen dos
opciones para disponer "Linear Layout(Horizontal)" o "Linear Layout(Vertical)" la
única diferencia es que se inicializa la propiedad "orientation" con el valor:
horizontal o vertical.
Podemos disponer más de una componente de tipo LinearLayout para
implementar nuestra interfaz visual. Veamos los objetos y propiedades a
configurar si queremos la siguiente interfaz:

Como vemos hemos dispuesto dos LinearLayout el primero con orientación
horizontal con los botones con las etiquetas "BOTON A", "BOTON B" y "BOTON
C". Luego de disponer los botones podemos observar que el LinearLayout ocupa
todo el alto de la pantalla (para que ocupe solo el espacio de la altura de los
botones debemos seleccionar el Linear Layout y cambiar la propiedad
"layout:height" por el valor: "wrap_content" asegurarse que está seleccionado el
LinearLayout y no alguno de los botones):

Arrastremos el segundo LinearLayout vertical dentro del RelativeLayout
(podemos arrastrarlo sin problemas a la interfaz visual o arrastrarlo a la ventana

"Component Tree", pero lo importante que quede al mismo nivel que el primer
Layout y no dentro del otro LinearLayout y lo redimensionamos para que quede
debajo del otro en pantalla):

Ahora podemos arrastrar un conjunto de botones dentro del segundo Layout:

Eliminando el RelativeLayout de la raíz de la aplicación.

Si no necesitamos que la raíz de la interfaz defina un RelativeLayout podemos
disponer en su lugar por ejemplo un LinearLayout. Modificaremos el programa
hecho hasta ahora de tal forma que la interfaz sea solo un LinearLayout con
orientación vertical y con 5 botones en su interior.
No lo podemos hacer en forma visual con Android Studio, debemos modificar
manualmente el código del archivo XML, cambiamos la vista "Design" por "Text":
Procedemos a modificar el nombre del Layout y definir e inicializar la propiedad
"orientation" (Remplazamos el nombre RelativeLayout por LinearLayout y
agregamos la propiedad android:orientation="vertical"):

Ahora podemos disponer los botones en la interfaz y aparecerán uno debajo del
otro similar a como empezamos pero será mas eficiente ya que no hay un
RelativeLayout en la raíz de la interfaz:

19 - Layout (TableLayout)
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)
Problema
Disponer 9 botones en forma de un tablero de TaTeTi. Utilizar un TableLayout,
tres TableRow y nueve botones.
Primero creemos el Proyecto021 y vamos a la pestaña Layout, identifiquemos la
componente "TableLayout" y la arrastramos al interior de la interfaz visual:

Luego de esto tenemos toda la pantalla cubierta con una componente de tipo
"TableLayout", ahora tenemos que empezar a disponer cada uno de los botones
e ir creando las filas.

El entorno del Android Studio nos facilita la creación de las filas del TableLayout,
debemos arrastrar las componentes que tendrá cada fila y automáticamente irá
creando cada "TableRow". Probemos de arrastrar el primer botón dentro del
"TableLayout", lo ubicaremos en la primer celda de la primer fila:

Una vez que lo dejamos caer dentro de la celda de la primer fila y columna que
nos muestra el Android Studio podemos ver que se han creado un objeto de la
clase "TableRow" y dentro de éste está el botón:
Lo mismo hacemos para agregar los dos botones que faltan en la primer fila,
seguidamente agregamos los tres botones de la segunda fila y los tres botones
de la tercer fila:

Otra posibilidad que nos da este Layout es que un control se expanda más de
una celda.
Disponer un botón en la cuarta fila del TableLayout y luego con el mouse
expandirlo para que ocupe tres celdas (cuando hacemos esto la propiedad
layout_span del objeto se inicializa con la cantidad de celdas que ocupará:

20 - Layout (FrameLayout)
El control de tipo FrameLayout dispone dentro del contenedor todos los controles
visuales alineados al vértice superior izquierdo,centrado, vértice inferior derecho

etc. (tiene nueve posiciones posibles).
Si disponemos dos o más controles los mismos se apilan.
Por ejemplo si disponemos dentro de un FrameLayout un ImageView y un Button
luego el botón se superpone a la imagen:
Una actividad posible 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 aplicación mostrar solo el botón y al ser presionado ocultar el botón y
hacer visible la imagen que muestra el ImageView.
Creamos una interfaz visual similar a la siguiente:

Inicializar la propiedadsrc del objeto de la clase ImageView eligiendo una imagen
en el diálogo "Resources" en la pestaña "System" donde se encuentran todas la
imágenes que tiene el sistema operativo Android por defecto.
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 onClick del control Button indicando el nombre
del método que se ejecutará al ser presionado (onClick: ocultar):
El código fuente de la clase es:

import android.widget.Button;
import android.widget.ImageView;
AppCompatActivity {
private ImageView iv1;
private Button b1;
@Override
iv1=(ImageView)findViewById(R.id.imageView);
b1=(Button)findViewById(R.id.button);
}
public void ocultar(View v) {
b1.setVisibility(View.INVISIBLE);
iv1.setVisibility(View.VISIBLE);
}
}
Cuando se presiona el botón procedemos a ocultar el botón y hacer visible la
imagen:
public void ocultar(View v) {
b1.setVisibility(View.INVISIBLE);
iv1.setVisibility(View.VISIBLE);
}

Manual de android parte 1

Más contenido relacionado

Similar a Manual de android parte 1 (20)

Último (20)

Manual de android parte 1