1. Manual Básico para la Creación de Bases de
Datos con SQLite en Android OS
Juan Sebastián Sánchez Gómez
Ingeniería de Sistemas
Universidad Manuela Beltrán
Cuando hablamos de Dispositivo móviles, estamos acostumbrados a escuchar
sobre los “Smartphone”, teléfonos inteligente dominados por sistemas operativos
como iOS, Windows Phone y Android.
Este último, Android, domina el mercado de los Smartphone, gracias a que la gran
mayoría de las aplicaciones de su Market (Google Play 1
) se consiguen gratuitas, y
en la web encontramos gran cantidad de herramientas para su desarrollo.
Desde su lanzamiento en el año 2000, SQLite 2
un ambicioso proyecto de dominio
público, entiéndase por esto, un motor de base de datos de libre acceso, que no
necesita de un servidor, y con la principal ventaja de poseer una librería portable
de apenas (apróx. 275 Kb).
Ahora bien, es posible integrar SQLite al sistema operativo móvil Android, gracias
al paquete android.database.sqlite 3
, el cual contiene las clases de bases de
datos SQLite, utilizadas para la gestión de nuestra base de datos privada.
Para hacer posible esta integración, es necesario tener los conocimientos básicos
en POO (Programación Orientada a Objetos) y en el lenguaje de programación
Java.
Para el presente manual, haremos uso de software libre, el cual podemos
descargar y utilizar gratuitamente todos sus componentes, como el IDE (Entorno
de Desarrollo Integrado) de Eclipse Índigo 4
, que consiste en un conjunto de
herramientas de programación en Java, que incluye un editor de código, un
compilador, un depurador y un constructor de interfaz gráfica (GUI).
De igual forma, necesitaremos la SDK (Kit de Desarrollo de Software) de Android
para Windows 5
, que es el conjunto de herramientas para el desarrollo de
aplicaciones en Android OS, esto incluye las API (Interfaz de Programación de
Aplicaciones), entiéndanse como las diferentes versiones de Android (en nuestro
caso la API 10 Android Gingerbread).
2. Procedimiento:
Creación de un Proyecto Android en Eclipse:
Antes que nada, debemos crear un Proyecto Android:
Figura 1. File >> New >> Other
Figure 2. Android >> Android Project >> Next
3. Figure 3. Create Android Project
Figura 4. Damos un nombre al Proyecto >> Next
Figura 5. Seleccionamos la Target Android para la cual se va a desarrollar la app.
4. Figura 6. Por último damos un nombre al paquete (Package Name) >> Finish
Después de finalizar la creación se aprecian las siguientes carpetas del proyecto
Ejemplo1. Encontramos la carpeta Android 2.3.3 donde están las librerías de la
API 10, la carpeta src (source) donde están contenidas las clases en el paquete, la
carpetagen (Generated Java Files) donde están los archivos creados por defecto
(R.java, BuildConfig.java); la carpeta res, que contiene drawable (imágenes e
iconos), layout (formularios xml) y values (variables String) y por último en
relevancia están los archivos Android Manifest (el archivo manifiesto para
permisos) y Project.properties, creado por defecto.
5. Desarrollo Interfaz Grafica de la Aplicación
En primer lugar, vamos a diseñar la interfaz de nuestra aplicación para el usuario
final, para esto, debemos tener en cuenta: la presentación, simplicidad y
funcionalidad. Cuando hablamos de presentación, tienen lugar los componentes
visuales con los que el usuario interaccionará; simplicidad, consiste en el fácil
acceso y control de estos componentes, y funcionalidad, es cumplir con las
prestaciones y el perfil para el cual fue desarrollada nuestra aplicación.
Android, hace uso de formularios .xml, con los cuales diseñamos la interfaz gráfica
de nuestra aplicación, para esto vamos a crear el pantallazo principal.
Por defecto, Eclipse crea un formulario principal al que nombre main.xml, para
acceder a él, vamos al package explorer, en la parte izquierda, buscamos el
proyecto Android que creamos “Ejemplo1”… como se muestra en la Fig. 7.
Ejemplo1 >> res >> layout >> main.xml
Figura 7. Diseño Interfaz main.xml
6. Figura 8. Formulario main.xml
Este es el pantallazo principal, es decir la
primera impresión que tiene el usuario de
la aplicación.
En ella, encontramos dos EditText, el
primero de ellos donde se ingresa la
cedula y el segundo para el nombre,
acompañados de sus respectivos
TextView (Cédula y Datos del
estudiante).
Además de ello, se puede apreciar tres
Button, el primero guarda los datos
ingresados (Insertar), el segundo
(Buscar) va a un segundo formulario
para realizar una búsqueda o consulta en
la base de datos, y el último termina la
aplicación (Cerrar)
Código Fuente main.xml
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:background="@drawable/fondo"
>
<RelativeLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_below="@+id/main_button_cerrar"
android:layout_margin="40px"
android:padding="5px"
android:background="#99000000"
android:layout_centerHorizontal="true"
android:visibility="invisible"
android:id="@+id/main_relativelayout_exito"
>
8. Figura 9. Formulario búsqueda.xml
Al hacer clic en el botón Buscar del
formulario main.xml, iremos a este
formulario, en el cual es posible hacer
una Búsqueda o Consulta en la base de
datos gestionada por SQLite.
Podemos apreciar, un EditText, en el cual
el usuario ingresara el criterio de
búsqueda, éste acompañado de su
respectivo TextView (Cédula) y un
TextView como título (Búsqueda).
También se tienen dos botones, el
primero Buscar, que inicia la búsqueda y
muestra los resultados, y el segundo
Anterior que nos devuelve al formulario
anterior main.xml. Por último,
encontramos un TextView, que nos
muestra el resultado de la búsqueda.
Código Fuente búsqueda.xml
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:background="@drawable/fondo"
>
<TextView
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="@string/titulo2"
android:id="@+id/busqueda_textview_titulo"
android:textColor="#ffffff"
android:layout_marginBottom="10px"
/>
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_below="@+id/busqueda_textview_titulo"
10. Desarrollo de las Clases:
Como bien sabemos, tenemos dos formularios main.xml y búsqueda.xml, pero los
objetos que están inmersos en ellos, no hacen nada hasta el momento, es por
esto que es necesario empezar a programar los atributos y los métodos a los que
se asocian los formularios, para dar funcionalidad a nuestra aplicación. Para ello,
vamos a hacer uso de tres clases: Ejemplo1.java, BD.java, búsquedas.java.
1) Ejemplo1.java
A esta clase está asociado el formulario principal main.xml, y desde este
formulario se ingresan los datos que se quieren insertar en la Base de datos.
Código Fuente Ejemplo1. Java
package ejemplo1.Ejemplo1;
//Se importan las librerías necesarias
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.view.Window;
import android.widget.Button;
import android.widget.EditText;
import android.widget.RelativeLayout;
import android.widget.TextView;
import android.view.View.OnClickListener;
public class Ejemplo1 extends Activity {
//Se declaran los objetos que se van a utilizar
Button buscar; //Objeto buscar de tipo Button (Botón)
Button cerrar; //Objeto cerrar de tipo Button (Botón)
Button insertar;//Objeto insertar de tipo Button(Botón)
BD datos;
EditText nombre;//Objeto nombre de tipo EditText (Caja de Texto)
EditText cedula;//Objeto cedula de tipo EditText (Caja de Texto)
//Define un layout donde la ubicacion de un elemento en la pantalla depende de otro componente
RelativeLayout exito;
RelativeLayout notificacion;
//Objeto alerta de tipo TextView notifica el exito o fracaso de la inserción de datos
TextView alerta;
public Thread hilo=new Thread();
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
requestWindowFeature(Window.FEATURE_NO_TITLE);
setContentView(R.layout.main);
//crear la base de datos
datos=new BD(this);
11. //Enlazar los instancias con los componentes de la interfaz
//Se referencian en la Clase R.java según el id que se le haya asiganado
cedula=(EditText) findViewById(R.id.main_edittext_cedula);
nombre=(EditText) findViewById(R.id.main_edittext_nombre);
buscar = (Button) findViewById(R.id.main_button_buscar);
cerrar = (Button) findViewById(R.id.main_button_cerrar);
insertar = (Button) findViewById(R.id.main_button_insertar);
notificacion=(RelativeLayout)findViewById(R.id.main_relativelayout_exito);
alerta=(TextView)findViewById(R.id.main_textview_exito);
buscar.setOnClickListener(new OnClickListener() {
//Al hacer clic en el Botón buscar, vaya a la siguiente clase "busquedas"
public void onClick(View v) {
// TODO Auto-generated method stub
Intent intent = new Intent(Ejemplo1.this, busquedas.class);
startActivity(intent);
//El TextView notificación hágalo invisible
notificacion.setVisibility(notificacion.INVISIBLE);
}
});
cerrar.setOnClickListener(new OnClickListener(){
//Al hacer clic en el Botón Cerrar finalice la ejecución de la aplicación
public void onClick(View v) {
// TODO Auto-generated method stub
finish();
}
});
//listener del boton para insertar los datos a la base de datos
insertar.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
//obtener el texto de las cajas de texto
String nom = nombre.getText().toString();
String ced = cedula.getText().toString();
if (ced != "" && nom != "") { //Si ced y num NO están vacíos
//insertar en la base de datos
long resultado=datos.insertarPersona(nom, ced);
cedula.setText(""); //Vaciar el campo de texto cedula
nombre.setText(""); //Vaciar el campo de texto nombre
if(resultado!=-1)
{
//mostrar mensaje de exito
alerta.setText("Insertado con éxito!!");
//Hacer visible el TextView notificacion
notificacion.setVisibility(notificacion.VISIBLE);
}
else //Si los campos de texto cedula y nombre estan vacíos
{
alerta.setText("Error al insertar!!");
notificacion.setVisibility(notificacion.VISIBLE);
}
}
}
});
}
}
12. 2) BD.java
En esta clase encontramos todas las herramientas necesarias para invocar los
métodos y atributos de una Base de Datos SQLite.
Código Fuente BD.java
package ejemplo1.Ejemplo1;
//Importamos las librerías necesarias
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.util.Log;
public class BD {
SQLiteDatabase db; //Objeto db de tipo Base de Datos SQLite
String tabla_personas ="CREATE TABLE IF NOT EXISTS personas (cedula INTEGER PRIMARY KEY,
nombre TEXT NOT NULL);";
String[] tablas={"personas"};
//Context es una clase que permite acceder a los servicios y recursos de android, en este
caso para acceder al servicio SQLite
public BD(Context ctx)//constructor
{
try{
//openOrCreateDatabase(String name, int mode, SQLiteDatabase.CursorFactory
factory);
//name nombre de la base de datos
//mode modo de operacion, 0 o privado por defecto para que solo pueda ser usado
por la aplicacion, gestion de los permisos
//factory clase que puede ser llamada para instanciar un cursor al usar un query,
null por defecto
//más info:
http://developer.android.com/reference/android/content/Context.html#openOrCreateDatabase%28java.lang
.String,%20int,%20android.database.sqlite.SQLiteDatabase.CursorFactory%29
db = ctx.openOrCreateDatabase("bdprueba", 0, null);
//execSQL(String sql);
//sql cualquier sentencia de sql que no sea un query, acepta create table, delete,
insert, etc
//más info:
http://developer.android.com/reference/android/database/sqlite/SQLiteDatabase.html#execSQL%28java.la
ng.String%29
db.execSQL(tabla_personas);
}
catch(Exception e){
//Log.d(String tag, String msg)
//tag para dar nombre al error
//msg mensaje del error
//más info:
http://developer.android.com/reference/android/util/Log.html#d%28java.lang.String,%20java.lang.Strin
g%29
Log.d("Base de Datos", "Exception initBD: "+ e.toString());
}
}
13. public long insertarPersona(String nombre, String cedula){
//ContentValues clase utilizada para almacenar un conjunto de datos
ContentValues cv = new ContentValues();
//put(String key, String value)
//key nombre del valor a insertar
//value dato a insertar
//más info:
http://developer.android.com/reference/android/content/ContentValues.html#put%28java.lang.String,%20
java.lang.String%29
cv.put("nombre", nombre);
cv.put("cedula", cedula);
//insert(String table, String nullColumnHack, ContentValues values)
//table tabla donde se va a insertar los datos
//nullColumnHack inserta una fila null en la base de datos en caso que no existan
datos a insertar
//values datos a insertar en la columna
//retorna -1 si hay error
//más info:
http://developer.android.com/reference/android/database/sqlite/SQLiteDatabase.html#insert(java.lang.
String, java.lang.String, android.content.ContentValues)
return db.insert("personas", null, cv);
}
public String obtenerPersona(int nt, String [] atributos, String condicion){
Cursor c=null;
try{
//query (String table, String[] columns, String selection, String[]
selectionArgs, String groupBy, String having, String orderBy, String limit)
//table nombre de la tabla a consultar
//columns columnas que quiere obtener en la consulta
//selection declarar cuales filas se van a retornar, condicion que se
utiliza para saber que filas consultar (WHERE)
//selectionArgs orden en el que va a apàrecer los argumentos de las consulta
//groupBy agrupas las filas
//having indica cuales filas se incluyen en la consulta
//orderBy ordenar las filas
//limit lmitar el numero de filas
//retorna un cursor que se posiciona en la primera fila de las obtenidas en
la consulta
//más info:
http://developer.android.com/reference/android/database/sqlite/SQLiteDatabase.html#query%28java.lang
.String,%20java.lang.String[],%20java.lang.String,%20java.lang.String[],%20java.lang.String,%20java.
lang.String,%20java.lang.String,%20java.lang.String%29
c = db.query(tablas[nt], atributos, condicion, null, null, null, null);
//apuntar al primer registro de lo obtenido en la consulta
c.moveToNext();
return c.getString(0);
}
catch (Exception e) {
Log.d("BASEDATOS", e.toString());
}
return "";
}
}
14. 3) busquedas.java
En esta clase, direccionaremos en la base de datos según el criterio de búsqueda
ingresado por el usuario, y se mostrar el resultado de la consulta. A dicha clase,
esta asociado el formulario búsqueda.xml.
Código Fuente busquedas.java
package ejemplo1.Ejemplo1;
import android.view.View.OnClickListener;
import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.view.Window;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
public class busquedas extends Activity {
//Se declaran los objetos que se van a utilizar
BD datos; //Objeto datos de la clase BD
EditText cedula; //Objeto cedula de tipo EditText (Caja de texto)
TextView resultado;//Objeto resultado de tipo TextView
Button buscar; //Objeto buscar de tipo Button (Botón)
Button anterior; //Objeto anterior de tipo Button (Botón)
String lectura=null;
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
requestWindowFeature(Window.FEATURE_NO_TITLE);
setContentView(R.layout.busqueda);
// TODO Auto-generated method stub
//crear la base de datos
datos=new BD(this);
//Enlazar los instancias con los componentes de la interfaz
//Se referencian en la Clase R.java según el id que se le haya asiganado
cedula = (EditText) findViewById(R.id.busqueda_edittext_nombre);
resultado=(TextView)findViewById(R.id.busqueda_textview_resultado);
anterior = (Button) findViewById(R.id.busqueda_button_anterior);
buscar = (Button) findViewById(R.id.busqueda_button_buscar);
anterior.setOnClickListener(new OnClickListener() {
//Al hacer clic en el Boton anterior finalizar la aplicación
public void onClick(View v) {
// TODO Auto-generated method stub
finish();
}
});
//listener del boton para recuperar los datos a la base de datos
buscar.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
//arreglo para almacenar los atributos a obtener en la consulta a la base de datos
String[] atributos = {"nombre"};
15. //llamar al método que recupera los datos
//Se envia:
//- La ubicacion de la tabla en el arreglo de tablas
//- La lista de atributos a obtener
//- Condición para la consulta
lectura = datos.obtenerPersona(0, atributos,
"cedula="+cedula.getText().toString());
//Determinar si se recupero algun registro de la base de datos para
imprimirlo en pantalla
if(lectura=="")
resultado.setText("Identificación no válida");
else{
resultado.setText(lectura);
}
}
});
}}
BIBLIOGRAFÍA
1. Google Play Store https://play.google.com/store
2. SQLite Official Page http://www.sqlite.org/index.html
3. SQLite for Android Developer
http://developer.android.com/reference/android/database/sqlite/package-
summary.html
4. Descarga Eclipse Índigo
http://www.eclipse.org/downloads/packages/release/indigo/sr2
5. Descarga Android SDK for Windows
http://developer.android.com/sdk/index.html
