PROGRAMACION DE TERMINALES MOVILES

5. SQLite

Profesor: Edwin Martnez Hernndez

edwin.mtz.hdez@gmail.com

Morelia, Michoacn, Mxico. 2013

2
3
4
5
Hay cuatro maneras de almacenar los datos en Android, usaremos
una u otra dependiendo de la funcin que tengan dichos datos.

Es importante destacar que los datos de cada aplicacin son privados

a dicha aplicacin, pero tenemos la posibilidad de compartirlos si as
lo deseamos

6
Existen cuatro tipos de datos distintos, en funcin de lo que
queramos almacenar.

Dichos tipos son:

1. Preferencias: Conjunto de datos, clave/valor

2. Archivos locales: Almacenamiento interno y externo (SD)
3. Base de datos: SQLite
4. Proveedores de contenidos: nico mecanismo para compartir
datos, no se trata con ellos directamente.

7
Tenemos a nuestra disposicin un tipo de datos llamado preferencias. Estas
preferencias, son una forma gil para poder guardar datos simples de la aplicacin.

Estos datos son un conjunto clave/valor que perdura despus de que la aplicacin
se cierre, por lo que es principalmente til para guardar, como su nombre indica,
las preferencias de una aplicacin.

Por ejemplo guardar el idioma, configuraciones de sonido de la aplicacin,

fuentes, colores, etc.

Los datos que permite guardar son primitivos y se invocan con los siguientes
mtodos putInt(), putBoolean(), putFloat(), putLong(), putString(), putStringSet()
de la forma (String key, tipo value).

8
SharedPreferences

Para Guardar y acceder a los datos de las preferencias se utiliza la clase que
hereda de PreferenceActivity, la cual guarda en un xml las preferencias de la
aplicacin que, en principio, sern cargadas cuando la iniciemos y guardadas
cuando la cerremos.

Dicho xml se guarda en SharedPreferences. Es importante destacar que podemos

tener una coleccin de preferencias, para ello tendremos que asociarles un
identificador.

Almacenndose los datos en:

/data/data/nombre_paquete/shared_prefs/mis_preferencias.xml
9
Para guardar los datos. Tenemos a nuestra disposicin los mtodos
onSaveInstance() y onStop().

Para guardar los datos :

1. Llamamos a edit(void) para editar las preferencias con

SharedPreferences.Editor.
2. Aadimos valores con los mtodos put
3. Actualizamos los nuevos valores usando commit(void)

10
private static final String PREFS_NAME = "mis_preferencias.xml";
..
.

protected void onStop(){

super.onStop();
// Necesitamos un objeto Editor para poder modificar las preferencias
SharedPreferences preferencias = getSharedPreferences(PREFS_NAME, 0);
SharedPreferences.Editor editor = preferencias.edit();
editor.putString("NumeroAlAzar", "58472");
// Por ejemplo un nmero al azar
// Actualizamos las nuevas preferencias
editor.commit();
}
11
Una vez que se tienen las preferencias guardadas, el siguiente cdigo muestra como
guardarlas:

public class PreferenciasActivity extends PreferenceActivity implements

OnSharedPreferenceChangeListener {
//... Tu cdigo
protected void onCreate(Bundle icicle) {
super.onCreate(icicle);
// Carga las preferencias del XML.
addPreferencesFromResource(R.xml.preferencias);
getPreferenceScreen().getSharedPreferences().registerOnSharedPreferenceChangeListener(this);
}
//... Tu cdigo
}

12
Preference Activity
Para hacer nuestras preferencias en xml.

Dichos xml se almacenan en /res/xml, y pueden constar de los siguientes tipos de opciones:

1. CheckBoxPreference: Check, valor booleano.

2. EditTextPreference: Cadena de texto.
3. ListPreference: Lista de seleccin nica.
4. MultiSelectListPreference: Lista de seleccin mltiple.

13
Codigo xml

<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android">
<PreferenceCategory>
TU CDIGO DE ESTA CATEGORA
</PreferenceCategory>
<PreferenceCategory>
TU CDIGO DE ESTA CATEGORA
</PreferenceCategory>
</PreferenceScreen>

14
Cuando hayamos definido nuestras preferencias, tendremos que
implementar una nueva actividad, para ello tendremos que crear una clase
que extienda de PreferenceActivity de la siguiente forma:

public class Opciones extends PreferenceActivity {

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
addPreferencesFromResource(R.xml.opciones);
}
}

15
Tambin tendremos que aadirla al Manifest como actividad, para
ello bastar con aadir el siguiente cdigo en el Manifest.

<activity android:name=".PantallaOpciones"
android:label="@string/app_name">
</activity>

16
A la hora de guardar distintos tipos de datos, que no se ajusten al patrn
clave/valor de las preferencias, tendremos que guardarlos como archivos
locales, dichos archivos, por defecto, no son accesibles desde otras
aplicaciones, regulado por permisos Unix. El acceso es parecido al de Java
estndar, debemos crear tanto input stream como output stream.

Puede soportar solamente archivos creados en la carpeta de la aplicacin.

Por lo que necesitamos saber dnde estn almacenadas las aplicaciones.

Estn almacenadas en:

/data/data/nombre_paquete/files/nombre_archivo

pudiendo almacenarse en la SDCard.

17
Para crear los output stream y los input stream, hay que destacar que en el
output stream tenemos que seleccionar el modo de acceso, que puede ser:

1. MODE_PRIVATE(por defecto) acceso privado desde nuestra aplicacin.

2. MODE_APPEND para poder aadir datos a un fichero existente.
3. MODE_WORLD_READABLE para permitir lectura a otras aplicaciones.
4. MODE_WORLD_WRITABLE para permitir escritura a otras aplicaciones.

18
Cdigo Ejemplo:

try
{
OutputStreamWriter fOut=
new OutputStreamWriter(
openFileOutput("texto_ejemplo.txt", Context.MODE_PRIVATE));
fOut.write("Cualquier cosa"); // Escribimos Cualquier cosa en fOut
fOut.close(); // Cerramos la escritura en el fichero fOut
}
catch (Exception e)
{
Log.e("Error de archivo", "Error al escribir el archivo.");
}

19
para los input hay que tener en cuenta que solamente podremos leer
aquellos archivos para los que tengamos permisos, el cdigo viene
detallado a continuacin.

try
{
BufferedReader fIn =
new BufferedReader(
new InputStreamReader(
openFileInput("texto_ejemplo2.txt")));
String texto = fIn.readLine(); // Tomamos la lnea de fIn
fin.close(); // Salimos para guardar la lnea
}
catch (Exception e)
{
Log.e("Error de Archivo", "Error al leer el Archivo");
}
20
Otra forma de almacenar datos en la memoria interna es
almacenarlo como recurso en la carpeta /res/raw de nuestro
proyecto, en eclipse dicha carpeta no se crea por defecto, tendremos
que crearla.

Es importante destacar que este mtodo de almacenamiento es til

para archivos que no vamos a modificar, ya que posteriormente
sern de solo lectura.

La forma de acceder a dichos archivos viene detallada a

continuacin.

21
try
{
InputStream fRaw =
getResources().openRawResource(R.raw.ejemplo_raw);
//ejemplo_raw es el nombre del fichero
BufferedReader bRIn =
new BufferedReader(new InputStreamReader(fRaw));
String linea = bRIn.readLine();
fRaw.close();
}
catch (Exception e)
{
Log.e("Error de Archivo", "Error al leer Archivo desde recurso");
}
22
La ltima alternativa para almacenar archivos locales ser la de guardarlos
en la memoria externa, que generalmente ser una tarjeta de memoria SD.

Es importante destacar que en el caso de la memoria externa, y al

contrario que con la memoria interna, puede no estar disponible ya sea
porque no est presente o porque el dispositivo no la reconoce.

Por esto tenemos que cerciorarnos de que est disponible antes de

utilizarla como sistema de almacenamiento, con ese fin usaremos el
mtodo getExternalStorageStatus() que nos devuelve el estado de la
memoria externa.

23
Segn queramos leer o escribir en ella los estados que nos
interesarn son:

MEDIA_MOUNTED que nos dice que podemos escribir y leer en

ella

MEDIA_MOUNTED_READ_ONLY que nos dice que est disponible

con permisos de solo lectura.

El siguiente fragmento de cdigo nos muestra una forma sencilla de

verificar el estado de la memoria externa y almacenarlo en dos
booleanos.

24
boolean tarjetaDisponible = false;
boolean tarjetaEscritura = false;
//Comprobamos el estado de la memoria externa (tarjeta SD)
String estadoTarjeta = Environment.getExternalStorageState();
if (estadoTarjeta.equals(Environment.MEDIA_MOUNTED)){
// Tarjeta disponible y habilitada para escritura
tarjetaDisponible = true;
tarjetaEscritura = true;
}
else if (estadoTarjeta.equals(Environment.MEDIA_MOUNTED_READ_ONLY)){
// Tarjeta disponible y deshabilitada para escritura
tarjetaDisponible = true;
tarjetaEscritura = false;
}
else{
// Tarjeta NO disponible
tarjetaDisponible = false;
tarjetaEscritura = false;
}
25
Tambin tendremos que indicar en el manifest que nuestra
aplicacin necesita permisos para almacenar datos en memoria
externa, para ello pondremos:

Codigo XML

<uses-permission android.permission.WRITE_EXTERNAL_STORAGE>
</uses-permission>

26
Ahora que sabemos el estado de la memoria externa y tenemos
permisos vamos a ver la ruta absoluta de la tarjeta de memoria.

Para ello usaremos el mtodo getExternalStorageDirectory() que nos

devolver un File, ahora ya podremos crear un archivo en la
direccin de dicho File como se muestra

27
try{
File ruta_tarjeta = Environment.getExternalStorageDirectory();
File f = new File(ruta_tarjeta.getAbsolutePath(), "ejemplo_tarjeta.txt");
OutputStreamWriter fOut =
new OutputStreamWriter(
new FileOutputStream(f));
fOut.write(Sonrie!! :D.");
fOut.close();
}
catch (Exception e){
Log.e("Error de Archivos", "Error al escribir Archivo en la tarjeta.");
}

28
Para leer de un archivo el cdigo es muy similar a la escritura

try{
File ruta_tarjeta = Environment.getExternalStorageDirectory();
File f = new File(ruta_tarjeta.getAbsolutePath(), "ejemplo_tarjeta.txt");
BufferedReader fIn =
new BufferedReader(
new InputStreamReader(
new FileInputStream(f)));
String linea = fIn.readLine();
fIn.close();
}
catch (Exception e){
Log.e("Error de Archivos", "Error al leer Archivo de la tarjeta.");
}
29
Android tiene integrado en el propio sistema una API completa que
nos permite manejar BD en SQLite. SQLite es un motor de bases de
datos que se ha ido popularizando en los ltimos aos dado que
maneja archivos de poco tamao, no necesita ejecutarse en un
servidor, cumple el estndar SQL-92 y, adems, es de cdigo libre.

El conjunto de la base de datos (definiciones, tablas, ndices, y los

propios datos), son guardados como un nico fichero en la mquina
host. Este diseo simple se logra bloqueando todo el fichero de base
de datos al principio de cada transaccin. Esta es, al mismo tiempo,
su gran virtud y su mayor inconveniente, ya que gracias a ello
dispone de unas latencias muy bajas, pero tambin impide el acceso
mltiple a la base de datos.
30
Caractersticas

Base de datos relacional para sistemas embebidos

Ocupa nicamente unos 225KB en memoria
No se trata de un proceso, sino de una librera que se aade
dinmicamente a las aplicaciones que quieren utilizar SQLite
Implementa la mayor parte del estndar SQL--92, pero con
restricciones
Soporte para ALTER_TABLE limitado
Las columnas no tienen tipos

31
Android soporta sqlite3, la manera ms fcil de acceder a la
informacin de una base de datos local es creando una clase que
herede de SQLiteOpenHelper sobre la cual tendremos que
adaptar/sobreescribir los mtodos proporcionados para obtener la
funcionalidad con la base de datos deseada.

Bsicamente en esta clase definimos los atributos de nuestra base

de datos y el comportamiento ante creacin y actualizacin de la
misma.

Los mtodos que deberemos sobrescribir sern onCreate() y

onUpgrade(), adems del constructor, donde podremos incluir todo
lo que creamos necesario.
32
El Siguiente es un ejemplo de como crear una base de datos de una entidad Domicilio que incluir como atributos: calle,
ciudad, CP y nmero. Crenado la clase DomicilioSQLiteHelper:

public class DomicilioSQLiteHelper extends SQLiteOpenHelper {

//Aqui creamos el String que crear la base de datos en el onCreate
String creaBD= "CREATE TABLE Domicilio (calle TEXT, ciudad TEXT, CP INTEGER, numero INTEGER)";

public DomicilioSQLiteHelper(Context context, String nombre, CursorFactory factory, int version) {

super(context, nombre, factory, version);
}
@Override
public void onCreate(SQLiteDatabase db) {
//Aqui se crea la BD, se llamara solo cuando no exista
db.execSQL(sqlCreate);
}
@Override
public void onUpgrade(SQLiteDatabase db, int a, int b) {
/*Utilizamos como opcin de actualizacin la de borrado de la tabla
anterior, para luego crearla vacia con la nueva versin*/
db.execSQL("DROP TABLE IF EXISTS Domicilio"); //Borrado anterior
db.execSQL(sqlCreate); //Creacin nueva
}
}
33
Cabe mencionar cuando se usarn los dos mtodos anteriores, el mtodo
onCreate() se ejecutar de maneara automtica cuando se necesite crear la
base de datos, lo que se reduce a cualquier llamada o referencia a la base
de datos mientras esta todava no exista.

Y el mtodo onUpgrade() que tambin ser llamado automticamente

cuando se produzca un cambio en la estructura de la base de datos, como
podra ser la inclusin/eliminacin de un campo en una tabla, en el cdigo
de ejemplo anterior hemos simplemente borrado la tabla anterior y creado
una tabla nueva vaca

Teniendo nuestra clase heredada SQLiteOpenHelper, estamos en

disposicin de utilizar los mtodos getReadableDatabase() o
getWritableDatabase() para acceder a la base de datos en modo lectura o
lectura/escritura.
34
Int version = 1;
String nombreDB = DomiciliosDB;
/****** Nuestro cdigo anterior aqu *******/
DomicilioSQLiteHelper domicilioHelper =
new UsuariosSQLiteHelper(this, nombreDB, null, version);
// Abrimos la Base de datos, en casa de que no existiera, se creara ahora
SQLiteDatabase db = domicilioHelper.getWritableDatabase();
//Insertamos 2 domicilios para inicializar la tabla
db.execSQL("INSERT INTO Domicilio(calle, ciudad, CP, numero) VALUES (C/Mayor, Madrid,
28001, 13)");
db.execSQL("INSERT INTO Domicilio(calle, ciudad, CP, numero) VALUES (Avda. Grande,
Ibiza, 26050, 45)");
//Cerramos la base de datos ya actualizada
db.close();
/****** Resto de cdigo *******/

35
Las funciones mas comunes de una base de datos en modo escritura son:

Insertar un registro
db.execSQL("INSERT INTO Usuarios (usuario,email) VALUES
('usu1','usu1@email.com') ");

Eliminar un registro
db.execSQL("DELETE FROM Usuarios WHERE usuario='usu1' ");

Actualizar un registro
db.execSQL("UPDATE Usuarios SET email='nuevo@email.com' WHERE
usuario='usu1' ");

36
Cursores

Los cursores sirven para recorrer el resultado de una base de datos como
un iterador.

Para ejecutar consultas sobre la clase domicilio, para ello, los permisos con
los que abriremos la base de datos de los domicilios sern slo de lectura.

37
Int version = 1;
String nombreDB = DomiciliosDB;
/****** Nuestro cdigo anterior aqu *******/
DomicilioSQLiteHelper domicilioHelper = new UsuariosSQLiteHelper(this, nombreDB,
null, version);
// Abrimos la Base de datos, en casa de que no existiera, se creara ahora
SQLiteDatabase db = domicilioHelper.getReadableDatabase();
Cursor c = db.rawQuery("SELECT ciudad, CP FROM Domicilio WHERE calle=Av. Madero");
//Obtenemos los indices de las columnas
int ciudadIndex = mCursor.getColumnIndexOrThrow(ciudad);
int CPIndex = mCursor.getColumnIndexOrThrow(CP);
// Posicionamos el cursor al principio de la lista
if (c.moveToFirst()) {
do {
//Obtenemos en nuestras variables los datos del registro que est leyendo.
String ciudad= c.getString(ciudadIndex);
int CP = c.getString(CPIndex);
} while(c.moveToNext());
/****** Resto de cdigo *******/
38
Los Content Providers son el mecanismo que tiene Android para
comunicar datos entre distintas aplicaciones. Funcionalmente suelen
ser muy parecidos a las bases de datos en SQLite.

El propio Android trae (desde sus versiones 2.0+) incluidos la agenda

,los SMS y el listado de llamadas mediante el mtodo de los Content
Providers, simplemente una aplicacin debe acceder a la URI donde
tenemos el Content Provider y una vez tengamos acceso pedirle los
datos que necesitemos.

39
Al igual que para las bases de SQLite para los Content Providers
deberemos crear una clase que herede de ContentProvider y
declararla en el manifest.

<application>....
<provider android:name="DomiciliosProvider"
android:authorities="com.pruebasandroid.ejemplo" />
<application/>

40
La facilidad de su uso reside en tener una base de datos que realice
las mismas funciones que los mtodos que tenemos que
sobreescribir, para llamarlos basta con hacer un buen uso de las
URIs.

A continuacin se muestra el cdigo, a modo de ejemplo, de

DomiciliosProvider:

41
package com.pruebasandroid.ejemplo;

public class DomiciliosProvider extends ContentProvider {

//Establecemos como una constante la URI para acceder a estos datos
private static final String uri = "content://com.pruebasandroid.ejemplo/domicilios";
//Uri del String anterior
public static final Uri CONTENT_URI = Uri.parse(uri);
//Necesario para UriMatcher
private static final int DOMICILIOS = 1;
private static final int DOMICILIOS_ID = 2;
private static final UriMatcher uriMatcher;

//Clase interna para declarar las constantes de columna

public static final class Clientes implements BaseColumns{
private Clientes() {}
// Inicializamos las columas, para poder acceder a ellas con un mnemotcnico
public static final String COL_CALLE = "calle";
public static final String COL_CP = "cp";
public static final String COL_NUMERO = "numero";
public static final String COL_CIUDAD = "ciudad;
}
42
//Los datos referentes a la base de datos, que creamos en el ejemplo anterior
private UsuariosSQLiteHelper helper;
private static final String NOMBRE_BD = "DomicilioDB";
private static final int VERSION = 1;
private static final String TABLA_DOMICILIOS = "Domicilios";
//Inicializamos el UriMatcher
static {
uriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
uriMatcher.addURI("com.pruebasandroid.ejemplo", "domicilios", DOMICILIOS);
uriMatcher.addURI("com.pruebasandroid.ejemplo", "domicilios/#",
DOMICILIOS_ID);
}
/*Sobreescribimos los mtodos de ContentProvider*/
@Override
public boolean onCreate() {
helper = new UsuariosSQLiteHelper(
this.getContext(), NOMBRE_DB, null, VERSION);
return true;
}

43
/*Aqui devolvemos el cursor de nuestra BD de domicilios*/
@Override
public Cursor query(Uri uri, String[] projection,
String selection, String[] selectionArgs, String sortOrder) {
/*Construimos un where si se refiere a un id concreto */
String where = selection;
if(uriMatcher.match(uri) == DOMICILIOS_ID){
where = "_id=" + uri.getLastPathSegment();
}
/*Escritura y lectura y devolvemos el cursor de nuestra base de datos*/
SQLiteDatabase db = helper.getWritableDatabase();
return (Cursor)db.query(TABLA_DOMICILIOS, projection, where,
selectionArgs, null, null, sortOrder);
}
@Override
public Uri insert(Uri uri, ContentValues values) {
/*para escribir, insertamos en la base de datos que nos proporciona*/
long id = 1;
SQLiteDatabase db = helper.getWritableDatabase()
id = db.insert(TABLA_DOMICILIOS, null, values);

44
/*Devolvemos su correspondiente Uri*/
Uri newUri = ContentUris.withAppendedId(CONTENT_URI, id);
return newUri;
}
@Override
public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
/* Aqui el cdigo para el update*/
}
@Override
public int delete(Uri uri, String selection, String[] selectionArgs) {
/* Aqui el cdigo para el delete*/
}

45
@Override
public String getType(Uri uri) {
int tipo = uriMatcher.match(uri);
switch (tipo){
case DOMICLIOS:
return "vnd.android.cursor.dir/vnd.pruebasandroid.domicilio";
case DOMICILIOS_ID:
return "vnd.android.cursor.item/vnd.pruebasandroid.domicilio"";
default:
return null;
}
}
}

46
Ahora empezaremos a trabajar con SQLite, con el interpretes de
comandos que el ADB (Android Debug Bridge) nos brinda para
conectar con un dispositivo virtual de Android e interactuar con el
mediante un shell de linux.

Iniciar sqlite3
1. Usando el AVD Manager o desde Eclipse, comenzaremos
iniciando un dispositivo virtual de Android
2. Despus abriremos una ventana de comandos de msdos y
debemos posicionarnos en el directorio platform-tools,
localizado donde tenemos instalado el android-sdk

47
3. Utilizamos el comando adb shell para conectar con la terminal

El simbolo # es el prompt, e indica que hemos conectado con

nuestro emulador y hemos iniciado una sesion de Linux.

Si hay un telefono o dispositivo conectado, hay que especificar

donde queremos conectarnos, si al emulador o al telefono, mediante
adb e shell (emulador) o adb d shell (dispositivo).

Y podemos empezar a introducir comandos en linux

48
4. Nos situamos en el directorio data y ah creamos un directorio
pruebas para trabajar

5. Una vez en el directorio pruebas, iniciamos SQLite creando una

base de datos, esta base de datos la almacenamos en un archivo
base.db

49
SQLite permite
ejecutar una serie de
comandos que
comienzan por un
punto.

Se puede ver una

lista de comandos
disponibles
introduciendo el
comando .help, .exit
lo utilizamos para
salir

50
Crear una tabla

Crearemos una tabla para nuestra Biblioteca mediante la sentencia

create de SQL.

Para ver la lista de tablas, se usa el comando .tables

Los tipos de datos mas comunes son text, integer y float

51
Para ver la definicin de una tabla usamos el comando .schema

Para introducir los datos utilizamos insert

Para comprobar el contenido de la tabla

52
Para cambiar el modo de visualizacin podemos usar .mode column

53
//Este es el codigo de la clase adicional para manejar la base de datos
package com.example.basedatosbibliotecaii;
import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteDatabase.CursorFactory;
import android.database.sqlite.SQLiteOpenHelper;
public class ManejaBaseDatos extends SQLiteOpenHelper {
private static final String NOMBRE_BASE="BibliotecaII.db";
public static final String ID="id";
public static final String NOMBRE_LIBRO="nombreLibro";
public static final String NOMBRE_AUTOR="autor";
public static final String EDITORIAL="editorial";
public static final String ISBN="ISBN";
private static final int VERSION=1;
public ManejaBaseDatos(Context context){
super(context, NOMBRE_BASE, null, VERSION);
}
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL("CREATE TABLE TablaLibros (id integer primary key autoincrement, nombreLibro text, autor text, editorial
text ,ISBN text);");
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL("DROP TABLE IF EXISTS TablaLibros;");
onCreate(db);
}
} 54
import android.os.Bundle;
import android.app.Activity;
import android.content.ComponentName;
import android.content.ContentValues;
import android.content.Intent;
import android.database.sqlite.SQLiteDatabase;
import android.view.Menu;
import android.view.View;
import android.widget.TextView;
public class AltasActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_altas);
}
public void clickAceptar(View btn){
TextView nombreLibro=(TextView) findViewById(R.id.txtNombreLibro);
TextView autor=(TextView) findViewById(R.id.txtNombreAutor);
TextView editorial=(TextView) findViewById(R.id.txtEditorial);
TextView ISBN=(TextView) findViewById(R.id.txtISBN);
inserta(nombreLibro.getText().toString(),autor.getText().toString(),editorial.getText().toString(),ISBN.getText().toString());
}
public void inserta(String nombreLibro, String autor, String editorial, String ISBN){
ManejaBaseDatos manejadb= new ManejaBaseDatos(this);
SQLiteDatabase db=manejadb.getWritableDatabase();
ContentValues cv=new ContentValues();
cv.put(manejadb.NOMBRE_LIBRO, nombreLibro);
cv.put(manejadb.NOMBRE_AUTOR, autor);
cv.put(manejadb.EDITORIAL, editorial);
cv.put(manejadb.ISBN, ISBN);
db.insert("TablaLibros", manejadb.NOMBRE_LIBRO, cv);
db.close();
/*String cadenavalues="(values('"+nombreLibro+"','"+autor+"','"+editorial+"','"+"','"+ISBN+"')";
db.execSQL("insert into TablaLibros (nombreLibro,autor,editorial,ISBN"+cadenavalues+") ;");*/
} 55
https://addons.mozilla.org/es/firefox/addon/sqlite-manager/

56
Para realizar una consulta se usa el metodo RawQuery, que
devuelve un objeto de tipo Cursor

Para escribir todos los elementos todos los elementos de la tabla

escribiriamos:

Cursor cursor=db.rawQuery("select * from TablaLibros",null);

El objeto Cursor contiene el resultado de la busqueda, ademas de

informacin sobre las filas y las columnas de las tabla.

Para extraer el contenido de la primera fila, primero hay que colocar

el cursor en el primer registro utilizando el metodo moveToFirst()

57
Para extraer las columnas almacenadas en el Cursor se utiliza el
mtodo getInt(i) o getString(i), dependiendo del tipo de datos que
contenga la columna (i).

Una vez que se obtienen los elementos solicitados, nos podemos

mover al siguiente registro con el mtodo moveToNext() y se
procede del mismo modo.

El metodo moveToNext() devuelve false si el Cursor est situado

en la ltima fila y true en caso contrario.

El nmero de filas contenidas en el Cursor se obtiene con

getCount() y el nmero de columnas con getColumnCount()

58
//Codigo para hacer las consultas de una tabla
Cursor cursor=db.rawQuery("select * from TablaLibros",null);
if(cursor.moveToFirst()==true){
Toast toast1 = Toast.makeText(getApplicationContext(),"Existen "+ cursor.getCount()+" Libros en la
Biblioteca", Toast.LENGTH_SHORT);
toast1.show();
for(int i=1;i<cursor.getCount();i++){
int var_id=cursor.getInt(0);
String var_nLibro=cursor.getString(1);
String var_nAutor=cursor.getString(2);
String var_editorial=cursor.getString(3);
String var_ISBN=cursor.getString(4);
toast1= Toast.makeText(getApplicationContext(),"Id "+ var_id+" Nombre
Libro:"+var_nLibro+" Nombre Autor:"+var_nAutor+" Editorial:"+ var_editorial+"
ISBN:"+var_ISBN, Toast.LENGTH_SHORT);
cursor.moveToNext();
}
}else{
Toast toast1 = Toast.makeText(getApplicationContext(),"No hay Datos en la Biblioteca",
Toast.LENGTH_SHORT);
toast1.show();
}
59
Para borrar filas de una tabla se puede utilizar el mtodo
execSQL(), en donde el parmetro debe de tener el o los registros a
eliminar dentro de la tabla correspondiente.

Ejemplo

db.execSQL("delete from TablaLibros where id=1;");

60
El mtodo query() de la clase SQLiteOpenHelper, requiere siete
parametros necesarios para realizar una consulta completa SQL

public Cursor query(String table, String[] columns, String selection,

String[] selectionArgs, String groupBy, String having, String
orderBy)

Para buscar todas las columnas y filas de una tabla, similar a un

select * from TablaLibro, solo de debe de proporcionar el primer
parametro que es el nombre de la tabla, quedando la instruccin de
la siguiente forma:

Cursor cursor=db.query("TablaLibros",null,null,null,null,null,null);

61
Otro ejemplo para utilizar el metodo query seria el siguiente:

String[] columns={"nombreLibro","nombreAutor"};
String "id>10";
String selectionArgs=null;
String groupBy=null;
String having=null;
String orderBy="id";
cursor=
db.query("TablaLibros",columns,selection,selectionArgs,groupBy,
having,orderBy);

62
El mtodo delete() de la clase SQLiteOpenHelper, se utiliza para
eliminar registros de una tabla y requiere tres parametros el primero
el nombre de la tabla, el segundo la condicion where de los registros
a borrar y el tercero regularmente se utiliza null

Ejemplo

db.delete("TablaLibros","id>1",null);

Que es equivalente a:

delete from operas where id>1;

63
La Clase CursorAdapter permite adaptar un Cursor a un ListView y
as mostrar en una lista de items los resultados de bsqueda de una
base de datos.

con la clase SimpleCursorAdapter se pueden especificar las

columnas que se desean mostrar, asociando cada una de las
columnas a un TextView.

El ListView se asocia a su vez a su vez al layout de un archivo xml,

que contiene los distintos TextView.

Para construir un SimpleCursorAdapter se requieren cinco

argumentos

64
String[] from={"nombreLibro","nombreAutor"};
int[] to={R.id.nLibro,R.id.nAutor};
SimpleCursorAdapter adapter=new SimpleCursor
(this,R.layout.list,cursor,from,to);

El primer parametro es el contexto, es decir la actividad actual, this

El segundo es el identificador del layout correspondiente al archivo
list.xml
El tercero es el cursor que necesariamente debe de tener una
columna _id (en caso contrario se produce un error).
El cuarto elemento es un arreglo de cadenas que contienen las
columnas del cursor que se quieran escribir
El ultimo elemento es un arreglo de enteros que contienen los id de
los TextView
65
public class ListaConsultasActivity extends Activity {
TextView txtnombreLibro, txtnombreAutor;
ManejaBaseDatos manejadb= new ManejaBaseDatos(this);
SQLiteDatabase db=manejadb.getReadableDatabase();
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_lista_consultas);
txtnombreLibro=(TextView) findViewById(R.id.txtNombreLibro);
txtnombreAutor=(TextView) findViewById(R.id.txtNombreAutor);
//Realiza la busqueda
String [] columns={"_id","nombreLibro","nombreAutor"};
Cursor cursor=db.query("TablaLibros",columns,null,null,null,null,null);
//adapta el cursor al ListView
ListView lv=(ListView) findViewById(R.id.listView1);
String[] from={"nombreLibro","nombreAutor"};
int[] to={R.id.txtNombreLibro,R.id.txtNombreAutor};
SimpleCursorAdapter adapter=new SimpleCursorAdapter(this,R.layout.activity_lista_consultas,cursor,from,to);
lv.setAdapter(adapter);
lv.setOnItemClickListener((OnItemClickListener) this);
db.close();
}
public void onItemClick(AdapterView<?> listView, View v, int position, long id){
Cursor cursor=(Cursor) listView.getItemAtPosition(position);
int _id=cursor.getInt(0);
String nL=cursor.getString(1);
String nA=cursor.getString(2);
txtnombreLibro.setText(nL);
txtnombreAutor.setText(nA);
}
} 66
Las Bases de Datos SQLite son internas a cada aplicacin. Para que
nuestra base de datos u otros contenidos sean accesibles, se debe de
crear un proveedor de contenidos, extendiendo la clase
ContentProvider.

Android utiliza proveedores de contenidos nativos para almacenar

los contactos, las imgenes, los archivos multimedia, las
preferencias, las llamadas telefnicas, etc.

Cada ContentProvider posee un identificador unico, especificado

mediante una cadena de texto en formato URI (Uniform Resource
Location). Este identificador uniforme de recurso tiene una
estructura similar al URL(Uniform Resource Location) de una
pagina Web.
67
La URI de la tabla de contactos de Android es

content://com.android.contacts/contacts

Esta URI consta de varias partes:

El prefijo content es obligatorio e indica que se trata del URI de

un Content Provider.
La autoridad (authority) //com.android.contacts identifica al
proveedor de contactos. Este Nombre corresponde a una
aplicacin Android que nos da acceso a la base de datos que
contiene.
El path /contacts o ruta del contenido, que generalmente es el
nombre de una tabla en la base de datos
68
El URI de la tabla de contactos esta almacenado en una constante
estatica de la clase ContactsConstract. Esta clase contiene toda la
informacion y facilita el uso del proveedor de contactos. Este URI
se almacena en un objeto de tipo Uri, mediante:

Uri uriContactos=ContactsConstract.Contacts.CONTENT_URI;

Alternativamente si conocemos el URI completo, se puede utilizar

el metodo URI.parse

uriContactos=UriParse("content://com.android.contacts/contacts/17");

69
Analisis Ejercicios Libro

En Parejas

http://www.ugr.es/~amaro/android/book2.html

70