Ya trabajamos los
layout y algunas
clases de esta aplicación, en donde creábamos un archivo de texto y lo manejábamos mediante flujos (Stream), pero solo nos servia para crear y abrir un solo archivo (se podía mejorar eso, pero lo haremos mas eficiente aun). En esta ocasión haremos uso de una base de datos para guardar y recuperar información y de esta manera tener N cantidad de notas, así que manos a la obra.
Lo primero sera hacernos de una clase auxiliar y adaptarla a nuestras necesidades para que el manejo de los datos sea simple. Esta clase sera llamada
BDAdapter.java
El código fuente de esta clase es el siguiente:
package com.nayosx.nl;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.SQLException;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.util.Log;
public class DBAdapter {
public static final String KEY_ROWID = "_id";
public static final String KEY_TITULO = "titulo";
public static final String KEY_NOTA = "nota";
public static final String DATABASE_NAME = "DB_Notas_BDate";
public static final String DATABASE_TABLE = "BDate";
public static final int DATABASE_VERSION = 1;
public static final String TAG = "DBAdapter";
public static final String DATABASE_CREATE = "create table "+DATABASE_TABLE+"("+KEY_ROWID+" integer primary key autoincrement not null, "+
KEY_TITULO+" text not null, "+KEY_NOTA+" text not null);";
private final Context context;
private DatabaseHelper DBHelper;
private SQLiteDatabase db;
public DBAdapter(Context ctx)
{
this.context = ctx;
DBHelper = new DatabaseHelper(context);
}
public static class DatabaseHelper extends SQLiteOpenHelper{
public DatabaseHelper(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
// TODO Auto-generated constructor stub
}
@Override
public void onCreate(SQLiteDatabase db) {
// TODO Auto-generated method stub
try{
db.execSQL(DATABASE_CREATE);
}
catch(SQLException e)
{
e.printStackTrace();
}
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// TODO Auto-generated method stub
Log.w(DBAdapter.TAG, "se ha actualizado la base de datos");
db.execSQL("DROP TABLE IF EXIST"+DBAdapter.DATABASE_TABLE);
onCreate(db);
}
}
public DBAdapter abrir() throws SQLException
{
db = DBHelper.getWritableDatabase();
return this;
}
public void cerrar()
{
DBHelper.close();
}
public long insertarNotas(String titu, String nota)
{
ContentValues initVal = new ContentValues();
initVal.put(KEY_TITULO, titu);
initVal.put(KEY_NOTA, nota);
return db.insert(DATABASE_TABLE, null, initVal);
}
public Cursor getAllNotas()
{
String [] getMain = {KEY_ROWID,
KEY_TITULO,
KEY_NOTA
};
return db.query(DATABASE_TABLE, getMain, null, null, null, null, null);
}
}
A continuación la explicación del código de esta clase:
Las constantes estáticas
public static final String KEY_ROWID = "_id";
public static final String KEY_TITULO = "titulo";
public static final String KEY_NOTA = "nota";
public static final String DATABASE_NAME = "DB_Notas_BDate";
public static final String DATABASE_TABLE = "BDate";
public static final int DATABASE_VERSION = 1;
public static final String TAG = "DBAdapter";
public static final String DATABASE_CREATE = "create table "+DATABASE_TABLE+"("+KEY_ROWID+" integer primary key autoincrement not null, "+
KEY_TITULO+" text not null, "+KEY_NOTA+" text not null);";
Sirven para crear toda la base de datos, son muy simples de entender ya que ellas solas se explican, quizás la mas difícil de comprender sea la
DATABASE_CREATE, pero simplemente se trata de una sentencia SQL en donde le indicamos la tabla que queremos crear, así como todos sus campos y la llave primaria de dicha tabla.
las demás variables y el constructor de la clase DBAdapter
private final Context context;
private DatabaseHelper DBHelper;
private SQLiteDatabase db;
public DBAdapter(Context ctx)
{
this.context = ctx;
DBHelper = new DatabaseHelper(context);
}
Bueno si han leido un poco la documentacion de
Android sobre SQLiteOpenHelper, sabran que se necesita de un contexto (en este caso simplemente llamado
context)en el cual actuar, por esta razón nuestro adaptador crea una variable que sera utilizada dentro del constructor de nuestra clase
BDAdapter .
Ademas necesitamos crear una clase (llamada
SQLiteDatabase y como instancia
db) dentro de nuestra clase
BDAdapter (no es necesario hacerlo así, pero para ahorrar tiempo y espacio lo deje de esa manera).
Dentro del constructor de nuestra clase
BDAdapter, inicializamos el contexto y luego se lo asignamos al constructor de
SQLiteDatabase (Esto para mandarselo a la clase padre de SQLiteDatabase, es decir para mandárselo al constructor de la clase
SQLiteOpenHelper).
Se que suena confuso, pero esa es la forma adecuada de actuar con la clases
SQLiteOpenHelper.
La clase SQLiteDatabase
public static class DatabaseHelper extends SQLiteOpenHelper{
public DatabaseHelper(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
// TODO Auto-generated constructor stub
}
@Override
public void onCreate(SQLiteDatabase db) {
// TODO Auto-generated method stub
try{
db.execSQL(DATABASE_CREATE);
}
catch(SQLException e)
{
e.printStackTrace();
}
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// TODO Auto-generated method stub
Log.w(DBAdapter.TAG, "se ha actualizado la base de datos");
db.execSQL("DROP TABLE IF EXIST"+DBAdapter.DATABASE_TABLE);
onCreate(db);
}
}
Esta clase es la que realmente crea la base de datos, esta interna a nuestra clase DBAdapter, quizás muchos de ustedes ya hayan trabajado con ella. Su creación es simple, se comienza heredando de SQLiteOpenHelper la cual nos pedirá que creemos un constructor para comenzar a trabajarla, luego sobre escribimos los métodos onCreate() y onUpgrade(), los cuales nos permitirán crear y mejorar la base de datos.
El constructor simplemente inicializa el nombre de la base de datos así como su versión.
onCreate() se encarga de terminar el trabajo con el método execSQL() y como parámetro nuestra constante estática DATABASE_CREATE, no confundir el parámetro db (que hace uso del metodo execSQL() ), con la instancia db, ambas son ajenas y la diferencia entre ambas es grande.
onUpgrade() se encarga de hacer los ajustes a la base de datos, en caso de que creemos un nuevo campo en algunas de las tablas, o que creemos alguna tabla extra, recordemos que solo tenemos una tabla y que no necesitaremos hacer eso, pero es recomendable dejarlo de esa manera.
Los métodos de ayuda de DBAdapter
public DBAdapter abrir() throws SQLException
{
db = DBHelper.getWritableDatabase();
return this;
}
public void cerrar()
{
DBHelper.close();
}
public long insertarNotas(String titu, String nota)
{
ContentValues initVal = new ContentValues();
initVal.put(KEY_TITULO, titu);
initVal.put(KEY_NOTA, nota);
return db.insert(DATABASE_TABLE, null, initVal);
}
public Cursor getAllNotas()
{
String [] getMain = {KEY_ROWID,
KEY_TITULO,
KEY_NOTA
};
return db.query(DATABASE_TABLE, getMain, null, null, null, null, null);
}
Creo que estos metodos no necesitaran mucha explicación, ya que casi todos estan en español
abrir() retorna Una instancia
DBAdapter y simplemente le asigna a
db el valor (o como querramos llamarlo) del método estático
getWritableDatabase(), es decir le indica que queremos abrir nuestra base de datos.
cerrar() no creo que necesite explicación alguna.
insertarNotas() solamente esta esperando a que le mandemos valores, luego se encarga de insertarlos en la base de datos. Hace uso de ContentValue para luego mandarle todo el contenido al método
insert().
getAllNotas() nos ayuda a obtener todos los valores de la base de datos, haciendo uso del método
query()
Bueno hasta aquí lo que es referente a la base de datos, mas adelante le agregaremos otros métodos para eliminar, actualizar el contenido de ella (e implícitamente la de las notas).
La siguiente parte del tutorial tratara sobre el L
istView con el que mostraremos las notas (recuperando todo el contenido de nuestra base de datos), así que pendientes
