24-1-2022 Desarrollo de

aplicaciones Android l
Ingeniería en sistemas computacionales

Alumno: José Miguel García Galán

Prof: Daniel Guadalupe Moreno Becerril

José Miguel García Galán

TECNOLOGICO DE ESTUDIOS SUPERIORES CHALCO
 INDICE

Practicas: Pagina

1.- Sumadora de números……………………………………………..1

2.- Calculadora con intents…………………………………………….8

3.- Uso de intents con parámetros……………………………………16

4.- Login con Shared Preferences…………………………………….25

5.- WebService con Volley y php……………………………………...38

6.- CRUD con SQLite…………………………………………………...50

7.- MVC (beans)…………………………………………………………58

1
Desarrollo de una aplicación “Sumadora de números”

En esta practica se realiza una aplicación que suma dos números reales, con el

objetivo de empezar a familiarizarse con el IDE “Android Studio” utilizando el

lenguaje de programación “JAVA”.

1.- En esta parte del código de la línea 3 a 9 se importan las librerías con las que

vamos a trabajar, y en la línea 13 y 14 declaramos las variables que nos servirán

para enlazar con los elementos de la interfaz grafica.

2
2.- En esta parte enlazamos los controladores de la vista mediante la variable
estática “R”.

3.- Creamos la clase bolean “validar” para validar los campos y asegurar que no
queden vacíos ya que sin este procedimiento la aplicación tendera a fallar y
detenerse por defecto, utilizamos una variable tipo bolean y 2 variables mas tipo
String, se utiliza dos if para comprobar si los campos están vacíos o esta llenos.

3
4.-En esta parte del código se realiza la operación de la suma guardándola en una
variable que se llama rest y capturando los valores numéricos y convirtiéndolos en
un String para posteriormente imprimir el valor en pantalla con la ayuda de un Toast,
un toast es un tipo de popup que solo ocupa el espacio del texto a mostrar.

5.- En esta imagen se muestra todos los estilos y elementos gráficos que
aparecerán en la aplicación.

4
Resultado final
En esta pantalla se muestra el resultado de una suma de dos números enteros y en
la otra de una suma de números decimales, uno negativo y otro positivo.

5
Validación de los campos de texto.
En estas pantallas podemos comprobar como la aplicación le hace saber a el
usuario que no puede dejar campos vacíos para realizar la operación.

6
Conclusión
Con esta practica obtuvimos un amplio panorama de la IDE de desarrollo de
aplicaciones Android para en un futuro poder desarrollar aplicaciones mas
complejas, ya que con el desarrollo de esta nuestra primera aplicación nos
empezamos a familiarizar con las herramientas que nos brinda esta IDE, así mismo
utilizar el lenguaje de programación Java que es un lenguaje orientado a objetos,
también con esta practica aprendimos a estilizar un entorno grafico con varios
elementos y tipos de contenedores que son los que nos darán la vista de nuestra
aplicación, es muy divertido he interesante desarrollar aplicaciones en Android
estudio por que contiene un emulador que nos permite testear nuestra aplicación
conforme la vamos desarrollando.

7
8
Calculadora con intents.

Con esta practica se pretende aprender a usar el uso de Intents que es una
herramienta que nos permite controlar la navegación entre las pantallas de nuestra
aplicación, también aremos el uso de las operaciones matemáticas para calcular la
suma, división y raíz cuadrada de números que inserte el usuario por medio de los
elementos de texto editable en Android.

Desarrollo
1.- Creamos nuestra actividad principal la cual contiene 3 botones, que nos
servirán para poder navegar entre activitys.
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
tools:context=".MainActivity">

<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="Calculadora con INTENTS"
android:textAlignment="center"
android:textStyle="bold"
android:textSize="25sp"
android:textColor="@color/design_default_color_primary"
android:layout_marginBottom="10dp"/>

<Button
android:id="@+id/btnSuma"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="Suma"
android:layout_marginBottom="10dp"/>
<Button
android:id="@+id/btnRaiz"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="Raiz Cuadrada"
android:layout_marginBottom="10dp"/>
<Button
android:id="@+id/btnDivisión"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="Division"
android:layout_marginBottom="10dp"/>

</LinearLayout>

9
2.- Código comentado java de la activity principal
package com.mike.appcalculadora4853;

import androidx.appcompat.app.AppCompatActivity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

public class MainActivity extends AppCompatActivity {

Button btnSuma, btnRaiz, btnDivision;

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

//Enslaces
btnSuma = (Button) findViewById(R.id.btnSuma);
btnRaiz = (Button) findViewById(R.id.btnRaiz);
btnDivision = (Button) findViewById(R.id.btnDivisión);

//Oyentes de eventos
//Suma
btnSuma.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
//Se ejecuta el método para navegar de el activity principal a
el activity de sumar
abrirSuma();
}
});
//Se implementa el método onClick para detectar cuando el usuario
presiona el boton
btnRaiz.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
//Se ejecuta el método para navegar de el activity principal a
el activity de raiz cuadrada
abrirRaiz();

}
});
//Se implementa el método onClick para detectar cuando el usuario
presiona el boton
btnDivision.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
//Se ejecuta el método para navegar de el activity
principal a el activity de división
abrirDivision();
}
});

10
 }
//Métodos o acciones de navegacion entre activitys
private void abrirSuma(){
Intent intentSuma = new Intent(getApplicationContext(),
SumaActivity.class);
startActivity(intentSuma);

}
private void abrirRaiz() {
Intent intentRaiz = new Intent(getApplicationContext(),
RaizActivity2.class);
startActivity(intentRaiz);

}
private void abrirDivision(){
Intent intentDivision = new Intent(getApplicationContext(),
DivisionActivity3.class);
startActivity(intentDivision);
}
}

3.- Código comentado java para la operación de Suma.

public class SumaActivity extends AppCompatActivity {
EditText etNum1, etNum2;
Button btnCalcularSuma;
TextView tvResSuma;

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

//Enlaces
etNum1 = (EditText) findViewById(R.id.etNum1);
etNum2 = (EditText) findViewById(R.id.etNum2);
btnCalcularSuma = (Button) findViewById(R.id.btnCalcularSuma);
tvResSuma = (TextView) findViewById(R.id.tvResSuma);

//Oyentes
btnCalcularSuma.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
calcularSuma();
}
});
}
//Método para calcular la suma
private void calcularSuma(){
//Se captura la entrada de datos en lo campos
String n1 = etNum1.getText().toString();
String n2 = etNum2.getText().toString();
//Se implementa un controlador if para validar los campos
if(n1.equals("") || n2.equals("")) {
tvResSuma.setTextColor(Color.RED);

11
 tvResSuma.setText("Error: Debes llenar ambos campos!!");
Toast.makeText(getApplicationContext(), "Error: Debes llenar
ambos campos!!" ,Toast.LENGTH_LONG).show();
}
else {
//Se convierte la entrada de datos a tipo Double y se realiza
la suma.
tvResSuma.setTextColor(Color.BLUE);
double res = Double.parseDouble(n1) + Double.parseDouble(n2);
tvResSuma.setText("El resultado es: " + res );
Toast.makeText(getApplicationContext(), "El resultado es: "+
res ,Toast.LENGTH_LONG).show();
}
}
}

4.- Código Java para calcular la Raíz cuadrada.

public class RaizActivity2 extends AppCompatActivity {
EditText etNum01, etNum02;
Button btnCalculaRaiz;
TextView tvResRaiz;

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

//Enlaces
etNum01 = (EditText) findViewById(R.id.etNum01);
btnCalculaRaiz = (Button) findViewById(R.id.btnCalculaRaiz);
tvResRaiz = (TextView) findViewById(R.id.tvResRaiz);
//Oyentes
btnCalculaRaiz.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
CalculaRaiz();
}
});
//Método o funcion para calcular la Raíz Cuadrada
}private void CalculaRaiz(){
String n1 = etNum01.getText().toString();
//Si los campos no estan vacios (validación de campos)
if(n1.equals("")){
tvResRaiz.setTextColor(Color.RED);
tvResRaiz.setText("Error: Debes llenar el campo");
Toast.makeText(getApplicationContext(), "Error: Debes llenar
el campo!!" ,Toast.LENGTH_LONG).show();

}
//Se realiza la conversion de datos y se utiliza la clase Math
para calcular raiz cuadrada
else {
tvResRaiz.setTextColor(Color.BLUE);
double res = Math.sqrt(Double.parseDouble(n1));

12
 tvResRaiz.setText("El resultado es: " + res );
Toast.makeText(getApplicationContext(), "El resultado es: "+
res ,Toast.LENGTH_LONG).show();
}
}
}

5.- Código java comentado para calcular la división de 2 números.

public class DivisionActivity3 extends AppCompatActivity {
EditText etNum001, etNum002;
Button btnCalcularDivision;
TextView tvResDivision;

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

//Enlaces
etNum001 = (EditText) findViewById(R.id.etNum001);
etNum002 = (EditText) findViewById(R.id.etNum002);
btnCalcularDivision = (Button)
findViewById(R.id.btnCalcularDivision);
tvResDivision = (TextView) findViewById(R.id.tvResDivision);

//Oyentes
btnCalcularDivision.setOnClickListener(new View.OnClickListener()
{
@Override
public void onClick(View v) {
calcularDivision();
}
});
}
//Método para calcular la división
private void calcularDivision(){
String n1 = etNum001.getText().toString();
String n2 = etNum002.getText().toString();
//Verificando si los campos estan vacios, manda el siguiente
mensaje
if(n1.equals("") || n2.equals("")){
tvResDivision.setTextColor(Color.RED);
tvResDivision.setText("Error: Debes llenar ambos campos!!");
Toast.makeText(getApplicationContext(), "Error: Debes llenar
ambos campos!!", Toast.LENGTH_LONG).show();
}
//Restriccion para evitar errores de dividir entre 0
else if(n2.equals("0")) {
tvResDivision.setTextColor(Color.RED);
tvResDivision.setText("Error no se puede dividir entre 0!!");
Toast.makeText(getApplicationContext(), "Error no se puede
dividir entre 0!!", Toast.LENGTH_LONG).show();
//Si se cumplen las condiciones se realiza la operación
}else {

13
 tvResDivision.setTextColor(Color.BLUE);
//Se parsea de String a Double
double res = Double.parseDouble(n1) / Double.parseDouble(n2);
tvResDivision.setText("El resultado es: " + res );
Toast.makeText(getApplicationContext(), "El resultado es: "+
res ,Toast.LENGTH_LONG).show();
}
}
Resultados:
1.- Actividad principal y activity suma.

2.- Activity raiz cuadrada.

14
3.- Activity división

15
16
Desarrollo de una app usando Intents

Con esta práctica se pretende obtener las habilidades y competencias para

desarrollar aplicaciones Android de una manera optima y eficiente, esta practica se
trata de una Activity principal que contiene un Spinner que nos dará la opción de
seleccionar un color y este color se va a ver reflejado en una SecondActivity,
esperamos que con esta practica obtengamos mejor conocimiento de los
componentes que nos ofrece la librería de Java para poder realizar en un futuro
aplicaciones mas complejas.

Para esto utilizamos un Activity Principal con un Spinner que nos mostrara una serie
de colores para seleccionar, estos colores son cargados a el Spinner por medio de
un Array, también utilizamos varias Activitys secundarias que contendrán el color de
fondo que seleccionemos en el Spinner y un botón para regresar a la activity
principal, a la hora de seleccionar el item del Spinner nos enviara automáticamente
a el color seleccionado abriéndonos una Second Activity que instanciamos por
medio de una variable Intents, esta instancia lo que nos realiza es que nos va a
ejecutar la activity que contenga la opción seleccionada.

17
Desarrollo
1.- Empezamos por diseñar el main Activity principal para esto utiliamos un
LinearLayout, un TextView y un Spinner.

2.- En esta parte empezamos a programar la lógica de nuestro Activity, también se

puede ver como hemos creado el Array que contendrá nuestro Spinner.

18
3.- En esta parte hacemos la conexión de datos que contendrá el Spinner y el estilo
desplegable.

4.- En esta imagen se muestra la lógica para cada selección de item del Spinner
para esto utilizamos un if y un else, cada que seleccióne el usuario un item que
contendrá colores nos direccionara a una secondActivity con el color de fondo
seleccionado.

19
5.- Aquí podemos visualizar la acción que se realizara para cada selección de un
item por medio de un if, tambien instanciamos un Intent para mandar a llamar a la
SecondActivity de cada item que se seleccione.

6.- Aquí se muestra el diseño de las activitys cada una de ellas fue diseñada de
igual forma cambiando únicamente el color de fondo y agregando un botón para
retornar a la Activity principal.

20
7.- Aquí se muestra la programación del botón para retornar a la Activity principal,
como se observa en el circulo rojo tenemos cada una de las activitys con su
respectivo color.

Resultados:
Seleccionamos el color rojo en el Spiner y presionamos el botón back para retornar.

21
Color Verde

Color Azul

22
Color Negro

Color Amarillo

23
Color Blanco

Conclusión
Es importante aprender programación orientada a objetos ya que para programar
nuestras aplicaciones en Android Studio utilizamos el lenguaje de programación
Java , este lenguaje está conformado por diversas librerías que nos son de mucha
utilidad a la hora de programar, estas nos ayudan a ahorrar tiempo y recursos. Es
importante mencionar que aunque el lenguaje de programación es Java, el
entorno de desarrollo Android Studio cambia un poco el paradigma de
programación.
En el proceso de desarrollo tuve un error el cual fue no agregar el botón para
activar el Second Activity seleccionado en el spinner, por el usuario, en su lugar
automatice el spinner para que nos abra automáticamente la second activity a la
hora de seleccionar el item.

24
25
Desarrollo de una app Login con Shared Preferences.

Con esta práctica se pretende obtener las habilidades y competencias para

desarrollar aplicaciones Android de una manera optima y eficiente, esta practica se
trata de programar una aplicación de un login para tener un control de Acceso de
usuarios y a el mismo tiempo aplicar el tema de SharedPreferences que no es más
que datos que la aplicación va a almacenando para posteriormente personalizar la
experiencia del usuario. Se espera que con esta práctica obtengamos habilidades
nuevas para un mejor desarrollo de futuros proyectos.

Se utilizaran 2 activitys una primaria y otra secundaria, donde la MainActivity será

la pantalla donde el usuario se puede logear en esta activity agregamos elementos
de campos de texto y un botón para iniciar sesión, para esto validaremos los
campos de entrada de texto para tener mejor seguridad en nuestra aplicación y
asegurarnos de que el usuario inserte los datos que se le piden correctamente
también usaremos Intents para conectar la SecondActivity la cual contendrá por el
momento solo las opciones de cerrar sesión y salir de la aplicación.

26
Desarrollo
1.- Creamos un nuevo proyecto y después una Empty Activity.

2.- Primeramente empsaremos a diseñar nuestra Main Activity para esto

utilizaremos un Linear Layout.

27
3.- En esta imagen se muestra el diseño de nuestro Activity con todas sus
propiedades como son el color, tamaño, id de cada elemento agregado.

28
4.- Posteriormente creamos una nueva Activity la cual llamaremos “ActivityPrincipal”
ya que será la pantalla principal de nuestra aplicación donde se mostrara el menú
de la aplicación.

5.- El siguiente paso es crear un nuevo directorio que contendrá el menú de la

ActivityPrincipal.

29
6.- Ahora dentro de nuestra carpeta menu crearemos nuestro archivo XML que
funcionara como nuestra base para crear el diseño de nuestro menú.

7.- El paso siguiente es diseñar nuestro menú para esto abrimos nuestro archivo
XML ya creado para agregar los ítems que conformaran nuestro menú, en esta
imagen se puede ver como agregamos dos ítems uno para cerrar sesión y otro mas
para salir de nuestra aplicación.

30
8.- En la siguiente captura de pantalla en la línea 12 se muestra como declaramos
el objeto de tipo Button, en la línea 21 instanciamos una variable para enlazar
nuestras variables con nuestros elementos gráficos a su vez programamos el oyente
para para que se ejecute nuestra ActivityPrincipal que contendrá el menu cuando
se presione el botón de acceder, esto lo logramos mediante un Intent como se
puede ver en la línea 32 y 33 instanciamos una variable que nos va a ejecutar la
acción.

9.- En esta captura de pantalla en la línea 43 y 44 podemos ver la validación de los

campos con un método if, para asegurarnos de que no queden datos vacíos, de la
línea 45 a 49 instanciamos una variable para consultar los datos que tenemos
almacenados en nuestro SharedPreferences para posteriotmente comparlos con los
valores que contiene nuestra caja de texto.

31
10.- En la línea 50 a 54 validamos con un if si los datos coinciden entonces dará
acceso a la ActivityPrincipal de nuestra aplicación con un mensaje de Bienvenid@,
de lo contrario nos enviara una Toast con un mensaje avisándonos que los datos
ingresados son herroneos.

11.- Ahora programamos el botón de retorno el cual nos llevara a la MainActivity

Linea 24.

32
12.- Por ultimo creamos un método que llamamos logOut (línea 37), dentro de este
método creamos un Intent el cual nos servirá para la opción de Cerrar Sesión, estas
acciones son programadas en la línea 43 en adelante, utilizamos un Switch y dos
Cases para programar las acciones de cada opción seleccionada en el menú que
en este caso es Cerrar sesión y Salir de la aplicación.

33
Resultados
1.- Logeo con datos erróneos. 2.- Sesión iniciada.

34
3.- Cerrando Sesión 4.- Salir

35
5.- Campos vacíos

36
Conclusión
Es importante aprender programación orientada a objetos ya que para programar
nuestras aplicaciones en Android Studio utilizamos el lenguaje de programación
Java , este lenguaje está conformado por diversas librerías que nos son de mucha
utilidad a la hora de programar, estas nos ayudan a ahorrar tiempo y recursos. Es
importante mencionar que aunque el lenguaje de programación es Java, el entorno
de desarrollo Android Studio cambia un poco el paradigma de programación.

Con esta practica aprendimos como implementar un Menú y a añadir ítems que
realizan tareas cada que damos clic sobre ellas, así como utilizar
SharedPreferences para almacenar datos predeterminados y el usuario pueda
iniciar sesión en dicha aplicación, también aprendimos a crear objetos e instancias
para programar la lógica de nuestra apk.

37
38
Desarrollo de un Web Services
Con esta práctica se pretende obtener las habilidades y competencias para
desarrollar aplicaciones Android de una manera optima y eficiente, esta practica se
trata de desarrollar un servicios de web haciendo uso de lenguaje PHP para
programar nuestra API y MySQL como gestor de base de datos, así mismo
utilizaremos Android Studio para programar un login con el lenguaje de
programación de Java.

Para lograr esto aremos uso de una librería en especial esta librería que se llama
Volley que es una herramienta que nos ayudara a hacer solicitudes de datos
mediante el protocolo http y así mismo conectaremos nuestra API para realizar
dichas solicitudes y poder comprobar credenciales para podernos logear dentro de
nuestra aplicación.

39
Desarrollo
1.- Abrimos nuestro Xampp e inicializamos el servicio de apache y MySQL,
posteriormente en nuestro navegador entramos a phpmyadmin.

2.- creamos una nueva base de datos llamada “Agenda”.

40
3.- Ponemos nombre a nuestra tabla y definimos el número de columnas.

4.- Creamos nuestra llave primaria y los demás campos que contendrá nuestra
tabla.

41
5.- Insertamos algunos registros para hacer pruebas.

6.- Ahora programamos la conexión con la base de datos.

42
7.- Programamos nuestra API para mandar a traer datos por medio del método
POST.

8.- Abrimos Postman pára testear nuestra API.

43
9.- Ahora crearemos una nueva aplicación en Android para consumir la API, para
esto abrimos un nuevo proyecto.

10.- Procedemos a diseñar nuestro Login.

44
11.- Comprobamos si tenemos conexión desde el emulador de Android con el
servidor.

12.- El siguiente paso es añadir la librería de Volley a el motor de compilación

(Gradle).

45
13.- Ahora programamos la funcionalidad de la aplicación.
Para esto empezamos por crear algunos objetos que nos permitirán realizar
algunas acciones dentro de nuestra apk.

14.- Comprobamos que los campos de texto estén llenos.

46
15.- Lógica del programa.

47
Resultados.
Logeo con datos correctos.

Logeo con datos incorrectos.

48
Conclusión
Es importante aprender programación orientada a objetos ya que para programar
nuestras aplicaciones en Android Studio utilizamos el lenguaje de programación
Java , este lenguaje está conformado por diversas librerías que nos son de mucha
utilidad a la hora de programar, estas nos ayudan a ahorrar tiempo y recursos. Es
importante mencionar que aunque el lenguaje de programación es Java, el
entorno de desarrollo Android Studio cambia un poco el paradigma de
programación.
También es de gran importancia mencionar que gracias a el desarrollo de una API
podemos usar casi cualquier lenguaje de programación para podernos comunicar
con esta y hacer peticiones como insertar, borrar, actualizar, y consultar datos
desde nuestra aplicación a el servidor.

49
50
Practica 1: SQLite (Insert, Update, Delete, Read)
En esta practica aremos uso de la clase SQLiteOpenHelper para crear una base de datos y
posteriormente podremos insertar, consultar, actualizar y eliminar datos en la tabla que creamos,
con ayuda de una interfaz grafica diseñada con XML utilizamos elementos básicos como EditText,
Spinner, Button y ListView la cual nos permitir consultar los datos y mostrarlos en una lista.
Posteriormente recorreremos los datos de atrás hacia adelante.

Código fuente
1.- Clase BaseDatos.
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import java.util.ArrayList;
//Creamos una clase BaseDatos y heredamos la clase padre SQLiteOpenHelper
public class BaseDatos extends SQLiteOpenHelper {

public BaseDatos(Context context, String name,

SQLiteDatabase.CursorFactory factory, int version) {
super(context, name, factory, version);
}
@Override
//Creamos una tabla llamada contactos2
public void onCreate(SQLiteDatabase db) {
db.execSQL("CREATE TABLE contactos2 (id INTEGER, nombre TEXT,
apellidos TEXT)");
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int
newVersion) {
db.execSQL("DROP TABLE IF EXISTS contactos2");
db.execSQL("CREATE TABLE contactos2 (id INTEGER, nombre TEXT,
apellidos TEXT)");
}
}

2.- Clase principal main.

import android.content.ContentValues;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.os.Bundle;
import android.view.View;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ListView;
import android.widget.Toast;

import androidx.appcompat.app.AppCompatActivity;

51
import java.util.ArrayList;
public class MainActivity extends AppCompatActivity implements
View.OnClickListener {
//Elementos graficos del diseño
EditText e1,e2,e3,e4;
Button b1, b2,b3,b4;
//Instanciando conexion con la clase BaseDatos
BaseDatos conexion= new BaseDatos(this,"base33",null,2);
String nom, ap;
int id;
SQLiteDatabase sql, sql2, sql3, sql4;
//Contenedor de valores
ContentValues valores,valores2;
public ListView lv;
public ArrayList<String> lista;
public ArrayAdapter adaptador;
@Override
//Método constructor
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//Llamando a el método relacionarVistas()
relacionarVistas();
//Llamando el método llenar_lv
lista=llenar_lv();
//Definiendo el adaptador
adaptador = new ArrayAdapter(this,
android.R.layout.simple_spinner_item, lista);
lv.setAdapter(adaptador);
}
//Método para llenar la listView
public ArrayList llenar_lv(){
//Creamos un objeto Lista del arreglo
ArrayList<String> lista = new ArrayList<>();
//Método para leer los datos que contiene la BD
SQLiteDatabase database = conexion.getReadableDatabase();
//Consulta SQL
String q = "SELECT * FROM contactos2";
//Cursor para reccorrer los registros
Cursor registros = database.rawQuery(q,null);
//Cursor de mueve a primera posición
if(registros.moveToFirst()){
do{
lista.add("ID="+registros.getString(0)+
" NOMBRE = "+registros.getString(1)+
" APELLIDOS= "+ registros.getString(2));
}while(registros.moveToNext());
//Recorre hasta el ultimo registro
}
return lista;
}

52
 //Enlazamos la parte grafica con la lógica del programa con este
método
public void relacionarVistas(){
lv=(ListView)findViewById(R.id.lista);
e1=findViewById(R.id.u);
e2=findViewById(R.id.p);
e3=findViewById(R.id.idNum);
e4=findViewById(R.id.id);
b1=findViewById(R.id.bConsultar);
b1.setOnClickListener(this);
b2=findViewById(R.id.bActualizar);
b2.setOnClickListener(this);
b3=findViewById(R.id.bBorra);
b3.setOnClickListener(this);
b4=findViewById(R.id.bInserta);
b4.setOnClickListener(this);
}
//Método para limpiar los campos de la vista
public void limpiarCajas(){
e1.setText("");
e2.setText("");
e3.setText("");
e4.setText("");
}
@Override
public void onClick(View v) {
switch (v.getId()){
case R.id.bConsultar: //Caso para el boton consultar
ArrayList<String> lista2 = new ArrayList<>();
String datos="";
//Método para leer en la BD
sql = conexion.getReadableDatabase();//los objetos sql
tienen que ser diferentes en cada consulta
String campos[]=new String[]{"id,nombre,apellidos"};

Cursor
registro=sql.query("contactos2",campos,null,null,null,null,null);

registro.moveToLast(); //Mueviendo el cursor al

último elemento

if(registro.getCount()>=1){ //Comprobando el número de

registros existentes
//Comprobando si el cursor se encuentra uno antes del primer registro
while (!registro.isBeforeFirst()){ //BUCLE WHILE
datos +=
registro.getString(registro.getColumnIndex("id"));
datos += ", " +

registro.getString(registro.getColumnIndex("nombre"));
datos += ", " +

registro.getString(registro.getColumnIndex("apellidos"));

53
 lista2.add(datos);
datos="";
registro.moveToPrevious(); //Mueve el cursor a el
elemento anterior
}
}
//Creamos un objeto adaptador
adaptador = new ArrayAdapter(this,
android.R.layout.simple_spinner_item, lista2);
//Mostramos los datos en el ListView
lv.setAdapter(adaptador);
Toast.makeText(this, datos , Toast.LENGTH_LONG).show();
break;
//Caso para actualizar los datos
case R.id.bActualizar:
//Método para escribir en la BD
sql4=conexion.getWritableDatabase();
nom = e1.getText().toString();
ap = e2.getText().toString();
id = Integer.parseInt(e3.getText().toString());
valores = new ContentValues();
valores.put("id",id);//el contenedor de valores solo
acepta variables no objetos
valores.put("nombre",nom);
valores.put("apellidos",ap);
String argumentos[]= new String[]
{e4.getText().toString()};
int resultadoUp=
sql4.update("contactos2",valores,"nombre like
?",argumentos);
Toast.makeText(getApplicationContext(),
resultadoUp+"Registro
actualizado",Toast.LENGTH_SHORT).show();
limpiarCajas();
break;
//Caso para insertar datos
case R.id.bInserta:
//Método para escribir en la BD
sql2 = conexion.getWritableDatabase();

nom = e1.getText().toString();
ap = e2.getText().toString();
id = Integer.parseInt(e3.getText().toString());
valores2 = new ContentValues();
//Método put para insertar valores
valores2.put("id",id);//el contenedor de valores solo
acepta variables no objetos
valores2.put("nombre",nom);
valores2.put("apellidos",ap);
long i=sql2.insert("contactos2",null,valores2);
Toast.makeText(getApplicationContext(), "Registro "+i+"
insertados",Toast.LENGTH_SHORT).show();
limpiarCajas();

54
 break;
case R.id.bBorra:
sql3=conexion.getWritableDatabase();
String argumentos2[]= new String[]
{e4.getText().toString()};
//Método Delete para eliminar datos
int
resultado=sql3.delete("contactos2","id=?",argumentos2);
Toast.makeText(getApplicationContext(),
resultado+"Registros borrados",Toast.LENGTH_SHORT).show();
limpiarCajas();
break;
}
}
}
Resultado

1.- Insertar datos.

55
 2.- Consultamos los datos, el cursor recorre los registros de atrás hacia delante por medio
del bucle while y también recorremos de adelante hacia atrás con el bucle do-while.

3.- Actualizamos un dato por medio del nombre como id.

56
4.- Eliminamos a el usuario Pablo Marmol por medio del id.

57
58
Practica 2: SQLite Beans
En esta práctica aplicaremos el patrón de (MVC) modelo, vista, control, separando los datos
de la aplicación, la interfaz que ve el usuario de la lógica del negocio en tres componentes distintos,
también utilizaremos componentes “Beans” para reutilizar código y evitar código repetitivo en nuestro
código fuente.
La practica consiste en una aplicación para guardar usuarios en una base de datos, esta
aplicación nos permitirá insertar, eliminar, actualizar y buscar un usuario por medio de su id.

Código fuente:
1.- MainActivity (Vista)
import androidx.appcompat.app.AppCompatActivity;
import android.content.ContentValues;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.os.Bundle;
import android.view.View;
import android.widget.Adapter;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.EditText;
import android.widget.Spinner;
import android.widget.Toast;
import java.util.ArrayList;

public class MainActivity extends AppCompatActivity {

EditText id,nombre,direccion,peso;
Spinner edad;
String texto="";
String edades[]={"1","2","3","4","5"};
//String arreglo[]=new String[1000];
//Creamos un arreglo de objetos "u" de la clase usuarios
Usuarios u[]=new Usuarios[1000];
//Usuarios u= new Usuarios(MainActivity.this);//control
//Inicializando las variables
int edadSpiner=0;
int i=0;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//Inicializamos un contador que inicia de 0 a 1000
for (int j=0; j <1000; j++) {
//Creando objeto de la clase Usuarios y pasamos el contexto desde la
vista para que pueda crear la BD
u[i]= new Usuarios(MainActivity.this);
}
// u[0]=new Usuarios(MainActivity.this);
//Función o método relación de la vista con lógica
relacionarVista();

59
 //Obtiene el item seleccionado y lo guarda en la variable "edad"
edad.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener(){
//Spinner
@Override
public void onItemSelected(AdapterView<?> parent, View view, int
position, long id) {
switch (position){ //Control de selección para la variable
edadSpiner
case 0:
edadSpiner=1;
break;
case 1:
edadSpiner=2;
break;
case 2:
edadSpiner=3;
break;
case 3:
edadSpiner=4;
break;
case 4:
edadSpiner=5;
break;
}
}

@Override
//En caso de no seleccionar nada la variable edadSpiner será = 0
public void onNothingSelected(AdapterView<?> parent) {
edadSpiner=0;
}
});
}
//Método para relacionar vista con la lógica de programación
public void relacionarVista(){
id=(EditText)findViewById(R.id.id);
nombre=(EditText)findViewById(R.id.nombre);
direccion=(EditText)findViewById(R.id.direccion);
peso=(EditText)findViewById(R.id.peso);
edad=(Spinner) findViewById(R.id.edad);
//Creando un arreglo "adaptador" tipo String le pasa como parámetros el
contexto y el arreglo edades que contiene el vector de las edades
ArrayAdapter adaptador=new ArrayAdapter<String>(this,
android.R.layout.simple_spinner_dropdown_item,edades);
//Le pasamos el adaptador de edades a el Spinner
edad.setAdapter(adaptador);
}
//Método insertarBD
public void insertarBD(View vista){
//El objeto "u" de la clase "Usuario" invoca a el método "insertar" y le
pasa como argumentos las cajas de texto de la vista
String
texto=u[i].insertar(nombre.getText().toString(),direccion.getText().toString(),p
eso.getText().toString(),edadSpiner);
//Se invoca el método respuesta y le mandamos como argumento la variable

60
texto donde se almacena el arreglo
respuesta(texto);
i++; //Cada que se presione el botón insertar se creara un arreglo que
contiene los datos
}
//Método para eliminar
public void eliminarBD(View vista){
//
String texto=u[i].eliminar(id.getText().toString());
i--;
}
//Método para actualizar un registro
public void actualizarBD(View vista){
//El arreglo de objetos invoca a el método actualizar y le envía como
argumentos las cajas de texto
String
texto=u[i].actualizar(id.getText().toString(),nombre.getText().toString(),direcc
ion.getText().toString(),peso.getText().toString(),edadSpiner);
//Retorna
respuesta(texto);
}

public void buscarBD(View vista){

String texto=u[0].buscar(id.getText().toString());
//String texto=u[i].buscar(id.getText().toString());
respuesta(texto);
i++;
}

public void respuesta(String texto){

Toast.makeText(getApplicationContext(),texto,Toast.LENGTH_LONG).show();
}

2.- Clase Usuarios (Control)

import android.content.Context;
public class Usuarios {
private String nombre=""; //Atributos de la clase
private String direccion="";
private double peso=0.0;
private int edad=0;
BD objeto=null;
//Método constructor de la clase Usuarios recibe como parámetro el
contexto para que pueda crear la BD
public Usuarios(Context c){
//Creando un objeto de la clase BD le pasamos como argumentos el
nombre de la BD y la version de la BD para poder crear la BD
objeto= new BD(c,"usuariosEmpresa",null,2);//modelo
}
//Método insertar recibe como parámetros nombre, dirección, peso y
edad.
public String insertar(String n, String d, String p, int e){

61
 //Memoria volatil RAM
String regreso="";
//Guardando los datos que recibe como parámetros en memoria RAM
this.nombre=n;
this.direccion=d;
this.peso=Double.parseDouble(p);
//Condicional if para capturar valor de la selección del Spiner
if(edad<=5 && edad>=1) {
this.edad = e;
}else{
this.edad=0;
}
//El objeto de la clase BD invoca el método insertar de esta
misma clase y le manda como argumentos lo que guardo en memoria RAM
String
texto=objeto.insertar(this.nombre,this.direccion,String.valueOf(this.peso
),this.edad);
return texto; //Retorna lo que se guardo en la variable texto
}
//Método eliminar recibe como parámetro el id
public String eliminar(String id){
//Pone los campos en blanco
String resultado="";
this.nombre=null;
this.direccion=null;
this.peso=0;
this.edad=0;
String texto=objeto.eliminar(id);
return texto;
}

public String actualizar(String id, String n, String d, String p, int

e){
//Memoria RAM
this.nombre=n;
this.direccion=d;
this.peso=Double.parseDouble(p);
this.edad=e;
String texto=objeto.actualizar(id,
this.nombre,this.direccion,String.valueOf(this.peso),this.edad);
return texto;
}

public String buscar(String id){

String texto="";
String datos[]=objeto.buscar(id);
for (int i = 0; i <=4 ; i++) {
texto+=datos[i]+" ";
}
return texto;
}

public String getNombre() {

62
 return nombre;
}
}

3.- Clase BD (Modelo)

import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;

public class BD extends SQLiteOpenHelper {

SQLiteDatabase sql,sql2,sql3,sql4;
String regreso="";
//Instancia de la clase Diccionario para poder acceder a los métodos
Diccionario dic1=new Diccionario();
//Método constructor de la clase BD se manda a llamar desde vista
tiene como parámetros el contexto y nombre de la BD así como versión
public BD(Context context, String name,
SQLiteDatabase.CursorFactory factory, int version) {
super(context, name, factory, version);
}
//Crea la tabla le pasamos como argumento el método getCrearTabla
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL(dic1.getCrearTabla());
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int
newVersion) {
db.execSQL(dic1.getBorraTabla());
onCreate(db);
}
public String insertar(String n, String d, String p, int e){
//Método para escribir en la BD
sql=getWritableDatabase();
String datos[]=dic1.getDatos();
//Método para insertar datos
long
i=sql.insert(dic1.getTabla(),null,dic1.getContenedorValores(n,d,p,e));
return condicion((int)i);
}
public String eliminar(String x){
sql2=getWritableDatabase(); //Escribe en la BD
String argumento[]={x}; //Se crea un arreglo para pasarlo como
argumento
//El objeto sql2 invoca a el método delete
int
i=sql2.delete(dic1.getTabla(),dic1.getClausulaWhere1(),argumento);
return condicion((int)i);
}

63
 public String actualizar(String id, String n, String d, String p, int
e){
sql3=getWritableDatabase();
//String datos[]=dic1.getDatos();
String argumento[]={id};
int i
=sql3.update(dic1.getTabla(),dic1.getContenedorValores(n,d,p,e),dic1.getC
lausulaWhere1(),argumento);
return condicion((int)i);
}
public String[] buscar(String id){
sql4=getReadableDatabase();
String argumento[]={id};
Cursor
c=sql4.query(dic1.getTabla(),dic1.getDatos(),dic1.getClausulaWhere1(),arg
umento,null,null,null);
//sql4.close();
return dic1.consulta(c);
}
//Mensaje que se muestra para cada acción
public String condicion(int i){
if(i>0){
regreso="OPERACIÓN EXITOSA";
}else{
regreso="FALLO";
}
return regreso;
}

4.-Diccionario

mport android.content.ContentValues;
import android.database.Cursor;

public class Diccionario {

private String crearTabla="CREATE TABLE usuarios (id INTEGER PRIMARY
KEY AUTOINCREMENT, nombre TEXT, direccion TEXT, peso REAL, edad
INTEGER)";
private String tabla="usuarios";
private String borraTabla="DROP TABLE IF EXISTS usuarios";
private String datos[]={"id","nombre","direccion","peso","edad"};
private String clausulaWhere1="id=?";

public String getCrearTabla() {

return crearTabla;
}

public String getTabla() {

return tabla;
}

public String[] getDatos() {

return datos;

64
 }

public String getBorraTabla() {

return borraTabla;
}

public String getClausulaWhere1() {

return clausulaWhere1;
}

public String[] consulta(Cursor c){

String datos[]= new String[5];
c.moveToFirst();
int numeroR=c.getCount();
for (int j = 0; j < numeroR; j++) {
datos[0]=c.getString(c.getColumnIndex("id"))+" ";
datos[1]=c.getString(c.getColumnIndex("nombre"))+" ";
datos[2]=c.getString(c.getColumnIndex("direccion"))+" ";
datos[3]=c.getString(c.getColumnIndex("peso"))+" ";
datos[4]=c.getString(c.getColumnIndex("edad"))+"\n";
c.moveToNext();
}
return datos;
}

public ContentValues getContenedorValores(String n, String d, String

p, int e){
ContentValues valores = new ContentValues();
valores.put(datos[1],n);
valores.put(datos[2],d);
valores.put(datos[3],p);
valores.put(datos[4],e);
return valores;
}
}

65
Resultados

1.- Insertamos un usuario y lo mostramos con la búsqueda por medio de su id

2.- Actualizamos los datos de este usuario le cambiaremos el apellido y el peso, consultamos
el suario por medio de su id para verificar que se ha actualizado.

66
 3.- Ahora eliminaremos el usuario y lo consultaremos para comprobar que se ha eliminado
el registro.

Figura 3

Conclusiones:

Las preferencias compartidas (SharedPreferences) pueden ser usadas con facilidad para
guardar datos de la aplicación, podemos guardar muchos tipos de datos como valores numéricos,
Strings y Boolean, por eso se utilizan para guardar simples datos de la aplicación de una forma
consistente.
También aprendimos un poco más sobre las bases de datos en Android con la ayuda de la
herramienta SQLite, vimos herramientas como SQLiteOpenHelper que nos ayudan a crear, editar,
visualizar, eliminar entre otros nuestros modelos de bases de datos., Así como adaptadores
especializados para alimentar listas con ayuda de cursores. Es importante saber gestionar datos en
nuestras aplicaciones y con a ayuda de estas herramientas lo podemos hacer posible.
Podemos decir que existen múltiples herramientas que nos ayudan a mantener una
persistencia de datos en nuestras aplicaciones, en esta investigación obtuvimos mucho conocimiento
acerca de cuáles tecnologías podemos usar para cada situación que se nos presente a la hora de
programar aplicaciones móviles, ya que cada aplicación tiene diferentes requerimientos en cuanto a
la persistencia y el almacenamiento de datos, es importante conocer cada una de las herramientas
que nos ofrece Android Studio ya que a lo largo de nuestra carrera tenemos que saber elegir las
opciones adecuadas para resolver ciertas problemáticas que se presenten en el desarrollo de futuros
proyectos.

67