- Null.- el valor que es un puntero a nulo, (sin valor)
- Integer.- que son los valores de enteros, y según el tamaño SQLite le dará el tamaño de bytes
- Real.- Son valores con punto flotante de 8 bytes
- TEXT.- valores utilizados para todos los strings, de igual forma SQLite le asignara el tamaño necesario
- Blob.- nos permite guardar datos binarios, como fotografias, multimedia etc.
Nota: La buena practica nos dice que no es recomendable guardar valores multimedia en una base de datos, ya que el tamaño puede crecer de una manera exorbitante, perjudicando el performance de cualquier tipo de aplicación.
Bueno, haremos un ejemplo del uso de SQLite con Android, para hacerla un poco mas funcional, utilizaremos un ListView que vimos en la entrada anterior. El ejemplo consiste en una aplicación, que nos permita almacenar un titulo, con un respectivo subtitulo o cuerpo (ambos serían un tipo String), podremos insertar tantos registros como queramos, podremos modificarlos y eliminarlos de la base de datos. al seleccionar un elemento del ListView podremos ver los detalles de registro dentro de la aplicación, y asi poder modificar y eliminar dicho registro.
Para comenzar creamos un nuevo proyecto, como sabemos nos genera un Layout principal y una clase java que hace referencia a dicho Layout, pero por ahora eso no será o principal.
Como se dijo al inicio, vamos a utilizar un ListView, se cree que ya saben utilizarla y si no pueden leer la entrada anterior ListView tutotiales Android, entonces primero vamos a crear nuestra clase contenedora que será en donde vamos a almacenar los elementos para el ListView muy sencilla nuestra clase es algo así:
package com.example.sqliteandroid;
public class ContentItem {
int id;
String title;
String bodyText;
public ContentItem(String title, String bodyTitle, int id)
{
this.title = title;
this.bodyText = bodyTitle;
this.id = id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getBodyText() {
return bodyText;
}
public void setBodyText(String bodyText) {
this.bodyText = bodyText;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
}
Ahora vamos a crear nuestra clase Adaptador y su XML que en mi caso quedarían asi:
XML:
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical" >
<TextView
android:id="@+id/textView1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginLeft="30dp"
android:layout_marginTop="5dp"
android:text="Title"
android:textAppearance="?android:attr/textAppearanceLarge" />
<TextView
android:id="@+id/textView2"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginLeft="15dp"
android:layout_marginTop="5dp"
android:text="Body text"
android:textAppearance="?android:attr/textAppearanceMedium" />
</LinearLayout>
JAVA:
package com.example.sqliteandroid;
import java.util.List;
import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.EditText;
import android.widget.TextView;
public class MyAdapter extends BaseAdapter {
List<ContentItem> list;
Context context;
public MyAdapter(Context context, List<ContentItem> item) {
this.context = context;
this.list = item;
}
@Override
public int getCount() {
return list.size();
}
@Override
public Object getItem(int arg0) {
return list.get(arg0);
}
@Override
public long getItemId(int arg0) {
// TODO Auto-generated method stub
return arg0;
}
@Override
public View getView(int arg0, View arg1, ViewGroup arg2) {
View tempView = arg1;
if (arg1 == null) {
LayoutInflater inflater = (LayoutInflater) context
.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
tempView = inflater.inflate(R.layout.my_list_view, arg2, false);
}
TextView titleItem = (TextView) tempView.findViewById(R.id.textView1);
TextView subtitleItem = (TextView) tempView.findViewById(R.id.textView2);
ContentItem item = this.list.get(arg0);
titleItem.setText(item.getTitle());
subtitleItem.setText(item.getBodyText());
tempView.setTag(item.getId());
return tempView;
}
}
Nos limitamos a explicar esto pues ya se ha explicado con anterioridad, ahora modificamos nuestra interfaz gráfica para adaptar todo a nuestra aplicación, el XML nos quedaría asi:
XML:
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical" >
<LinearLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_marginLeft="10dp"
android:layout_marginRight="10dp"
android:layout_marginTop="10dp"
android:orientation="vertical" >
<EditText
android:id="@+id/title"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:ems="10"
android:inputType="text" />
<EditText
android:id="@+id/bodyText"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_marginBottom="5dp"
android:layout_marginTop="5dp"
android:ems="10"
android:inputType="text"
android:lines="3" />
<LinearLayout
android:layout_width="match_parent"
android:layout_height="wrap_content" >
<Button
android:id="@+id/buttonInsert"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_weight="1"
android:onClick="insert"
android:text="Inserta" />
<Button
android:id="@+id/buttonUpdate"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_weight="1"
android:onClick="update"
android:text="Actualiza" />
<Button
android:id="@+id/buttonDelete"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_weight="1"
android:onClick="delete"
android:text="Borra" />
</LinearLayout>
</LinearLayout>
<ListView
android:id="@+id/listView"
android:layout_width="match_parent"
android:layout_height="wrap_content" >
</ListView>
</LinearLayout>
Y en modo gráfico quedaría asi:
Ahora tenemos que crear una clase que nos de acceso a una base de datos, para poder crearla y tener acceso total a ella, para eso vamos al navegador de paquetes y en la carpeta src/ creamos un nuevo paquete, al paquete en blanco le creamos una nueva clase que sera nuestra clase que extiende o hereda de SqliteOpenHelper que es una clase que Android nos facilita para este tipo de manejo de bases de datos
Bien ya que tenemos todos los elementos con las caracteristicas necesarias para lo que queremos hacer, vamos a integrar todo en nuestro activity principal, nuevamente, explico cada parte del código en forma de comentarios:
package com.example.sqliteandroid;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import BD.DataBase;
import android.os.Bundle;
import android.app.Activity;
import android.view.View;
import android.widget.AdapterView;
import android.widget.EditText;
import android.widget.ListView;
public class SQLiteActivity extends Activity {
/*
* Declaracion de variables necesarias para los widget de la interfaz
* una base de datos que la inicializaremos con la que hemos creado
* y un ID que sera el id del registro que se toca dentro del ListView
*/
ListView listView;
EditText editTitle, bodyText;
DataBase database;
Integer currentID;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_sqlite);
database = new DataBase(getApplicationContext()); /*es muy importante inicializar la base de datos al inicio de la
aplicación, pues si alguna consulta o query se intenta ejecutar, no habrá error, simplemente no se guardará nada
y no se obtendrá nada*/
initInterfaz();/*inicializamos la interfaz grafica*/
initListView();/*en este caso inicializaremos el ListView con un método aparte con un fin es especifico
cada que se inserte modifique o elimine un registro, necesitamos que eso se refleje en nuestra interfaz, entonces
tenemos que volver a llenar el LIstView, solo invocando a ese método*/
}
private void initInterfaz () /*simplemente inicializamos la interfaz*/
{
listView = (ListView) findViewById(R.id.listView);
editTitle = (EditText) findViewById(R.id.title);
bodyText = (EditText) findViewById(R.id.bodyText);
}
private void initListView ()
{
/*
* este método nos va a refrescar la vista del ListView, con nuestro adaptador personalizado
*/
currentID = 0;
/*
* ponemos el idActual en 0
*/
List<ContentItem> lista = database.getAllReg();
/*
* creamos un List de ContentItem y le asignamos los valores guardados en la base de datos, con el
* método correspondiente en la clase dataBase
*/
if (lista != null) {
/*
* en este momento la lista se inicializó correctamente con los valores de la Base de datos
* inicializamos el adapter personalizado y le agregamos el escuchador de clicks.
*/
MyAdapter adapter = new MyAdapter(getBaseContext(), lista);
listView.setAdapter(adapter);
listView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> arg0, View arg1, int arg2,
long arg3) {
/*
* al tocar sobre una celda, los datos que pertenecen a dicha celda se colocarán dentro de los editText
* recojiendo de la base de datos, por medio del ID con su método correspondiente en la base de datos
*/
currentID = (Integer) arg1.getTag();
int id = currentID;
ContentItem newContent = database.getReg(id);
editTitle.setText(newContent.getTitle());
bodyText.setText(newContent.getBodyText());
}
});
}
else {
/*
* En este momento la lista no se inicializó con los valores de la base de datos
* asi que inicializamos la lista con un arrayList y se lo enviamos al adaptador para que no
* muestra absolutamente nada.
*/
List<ContentItem> newList = new ArrayList<ContentItem>();
listView.setAdapter(new MyAdapter(getApplicationContext(), newList));
}
}
private boolean checkFields ()
{
/*
* Este método nos revisa que los TextFields, tengan texto.
*/
boolean success = false;
if (editTitle.length() > 0)
{
if (bodyText.length() > 0) {
success = true;
}
}
return success;
}
/*
* A cada botón creado se le asignó un método onClik dentro de la interfaz y en el XML tambien se puede ver
* ese método debe de estar definido para que pueda funcionar el botón con un método en especifico al toque
* aqui se muestra el método para cada botón creado.
*/
public void insert (View view)
{
/*
* Primero se comprueba que exista texto dentro de los campos editText
* Se inserta el registro en la base de datos
* con el método creado dentro de la clase DataBase
* y se refresca el ListView
*/
if (checkFields()) {
database.insertReg(editTitle.getText().toString(), bodyText.getText().toString());
initListView();
}
}
public void update (View view)
{
/*
* Primero se comprueba que exista texto dentro de los campos editText
* Se Actualiza el registro actual, con los valores dentro de los editText
* utilizando el metodo correspondiente dentro
* de la clase DataBase y se refresca el ListView
*/
if (currentID > 0 && checkFields()) {
database.updateReg(editTitle.getText().toString(), bodyText.getText().toString(), currentID);
initListView();
}
}
public void delete (View view)
{
/*
* Se elimina el registro actual, con el metodo correspondiente dentro de la clase DataBase
* se refresca el ListView, y eliminamos lo que exista dentro de los editText por limpieza visual.
*/
if (currentID > 0) {
database.deleteReg(currentID);
initListView();
editTitle.setText("");
bodyText.setText("");
}
}
}
Con esto, tendremos los resultados esperados, insertando y recuperando informacion en una base de datos, espero les sirva, les guste, y comenten algo, sea bueno o malo. Saludos a todos
Para comenzar creamos un nuevo proyecto, como sabemos nos genera un Layout principal y una clase java que hace referencia a dicho Layout, pero por ahora eso no será o principal.
Como se dijo al inicio, vamos a utilizar un ListView, se cree que ya saben utilizarla y si no pueden leer la entrada anterior ListView tutotiales Android, entonces primero vamos a crear nuestra clase contenedora que será en donde vamos a almacenar los elementos para el ListView muy sencilla nuestra clase es algo así:
package com.example.sqliteandroid;
public class ContentItem {
int id;
String title;
String bodyText;
public ContentItem(String title, String bodyTitle, int id)
{
this.title = title;
this.bodyText = bodyTitle;
this.id = id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getBodyText() {
return bodyText;
}
public void setBodyText(String bodyText) {
this.bodyText = bodyText;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
}
Ya se ha explicado, en el antrada anterior el fin de esta clase.
Ahora vamos a crear nuestra clase Adaptador y su XML que en mi caso quedarían asi:
XML:
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical" >
<TextView
android:id="@+id/textView1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginLeft="30dp"
android:layout_marginTop="5dp"
android:text="Title"
android:textAppearance="?android:attr/textAppearanceLarge" />
<TextView
android:id="@+id/textView2"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginLeft="15dp"
android:layout_marginTop="5dp"
android:text="Body text"
android:textAppearance="?android:attr/textAppearanceMedium" />
</LinearLayout>
JAVA:
package com.example.sqliteandroid;
import java.util.List;
import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.EditText;
import android.widget.TextView;
public class MyAdapter extends BaseAdapter {
List<ContentItem> list;
Context context;
public MyAdapter(Context context, List<ContentItem> item) {
this.context = context;
this.list = item;
}
@Override
public int getCount() {
return list.size();
}
@Override
public Object getItem(int arg0) {
return list.get(arg0);
}
@Override
public long getItemId(int arg0) {
// TODO Auto-generated method stub
return arg0;
}
@Override
public View getView(int arg0, View arg1, ViewGroup arg2) {
View tempView = arg1;
if (arg1 == null) {
LayoutInflater inflater = (LayoutInflater) context
.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
tempView = inflater.inflate(R.layout.my_list_view, arg2, false);
}
TextView titleItem = (TextView) tempView.findViewById(R.id.textView1);
TextView subtitleItem = (TextView) tempView.findViewById(R.id.textView2);
ContentItem item = this.list.get(arg0);
titleItem.setText(item.getTitle());
subtitleItem.setText(item.getBodyText());
tempView.setTag(item.getId());
return tempView;
}
}
Nos limitamos a explicar esto pues ya se ha explicado con anterioridad, ahora modificamos nuestra interfaz gráfica para adaptar todo a nuestra aplicación, el XML nos quedaría asi:
XML:
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical" >
<LinearLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_marginLeft="10dp"
android:layout_marginRight="10dp"
android:layout_marginTop="10dp"
android:orientation="vertical" >
<EditText
android:id="@+id/title"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:ems="10"
android:inputType="text" />
<EditText
android:id="@+id/bodyText"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_marginBottom="5dp"
android:layout_marginTop="5dp"
android:ems="10"
android:inputType="text"
android:lines="3" />
<LinearLayout
android:layout_width="match_parent"
android:layout_height="wrap_content" >
<Button
android:id="@+id/buttonInsert"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_weight="1"
android:onClick="insert"
android:text="Inserta" />
<Button
android:id="@+id/buttonUpdate"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_weight="1"
android:onClick="update"
android:text="Actualiza" />
<Button
android:id="@+id/buttonDelete"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_weight="1"
android:onClick="delete"
android:text="Borra" />
</LinearLayout>
</LinearLayout>
<ListView
android:id="@+id/listView"
android:layout_width="match_parent"
android:layout_height="wrap_content" >
</ListView>
</LinearLayout>
Y en modo gráfico quedaría asi:
Ahora tenemos que crear una clase que nos de acceso a una base de datos, para poder crearla y tener acceso total a ella, para eso vamos al navegador de paquetes y en la carpeta src/ creamos un nuevo paquete, al paquete en blanco le creamos una nueva clase que sera nuestra clase que extiende o hereda de SqliteOpenHelper que es una clase que Android nos facilita para este tipo de manejo de bases de datos
En la imagen anterior podemos ver el nombre de la superclase, el paquete en el que la colocamos y el nombre que se le dió a la nueva clase, cabe mencionar que hacer la diferenciación de paquetes y division de ellos, es con el simple fin de tener organizado nuestro código y asi tener acceso mas rápido a ciertas clases de apoyo que vamos creando, por el momento pareciera que no es necesario, pues no creamos mas de 5 clases extra, pero en proyectos más grandes será de gran utilidad tener divididos en paquetes (carpetas) las clases que vamos utilizando.
Una vez creada la clase que extiende o hereda de SliteOpenHelper, tenemos que dar acceso a nuestra propia base de datos, por ahora solo crearemos una tabla, que guardará un ID de registro, titulo, y cuerpo, de esta forma, nuestra clase quedaria con un codigo similar a este.
package BD;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
public class DataBase extends SQLiteOpenHelper {
/*
* creamos un objeto tipo SQLiteDataBase que es la referencia a la
* base de datos que estaremos gestionando, el contexto de la app
* la version de la base de datos que estamos utilizando y el nombre
* que le asignamos a la base de datos creada
*/
SQLiteDatabase bdControl;
Context thisContext;
private static final int VERSION_BASEDATOS = 1;
private static final String NAME_BD = "test.db";
public DataBase (Context context)
{
/*
* este constructor invoca al super constructor, inicializando nuestra clase, ahora
* podemos obtener la base de datos lista para modificar, insertar y eliminar registros.
*/
super(context,NAME_BD,null,VERSION_BASEDATOS);
bdControl = this.getWritableDatabase();
}
@Override
public void onCreate(SQLiteDatabase arg0)
{
/*
* el onCreate de la clase SQLiteOpenHelper crea la base de datos si no existe
*/
String createTable = "CREATE TABLE Nota (idReg INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, title TEXT, body TEXT);";
arg0.execSQL(createTable);
}
@Override
/*
* Este metodo, nos sirve para actualizar modificaciones en la base de datos
* no lo utilizaremos por el momento
*/
public void onUpgrade(SQLiteDatabase arg0, int arg1, int arg2) {
}
Bien, ahora tenemos acceso a la base da datos, ya tenemos nuestro constructor de nuestra clase que nos ayudará con los registros de la base de datos, pero queremos que "todo el trabajo sucio" lo haga esta clase, entonces vamos a crear metodos que nos permitan eso, sin necesidad de enviar Inserts, Updates, o Delete por fuera, que la clase lo haga todo, entonces vamos a agregar algunos métodos que nos permitan solo enviar variables y recibir variables, olvidandonos por fuera de que es una base de datos como tal, para este ejemplo solo agregaremos unos cuantos métodos pues solo tenemos una simple tambla, agregando métodos nos quedaría algo asi:
package BD;
import java.util.ArrayList;
import java.util.List;
import com.example.sqliteandroid.ContentItem;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
public class DataBase extends SQLiteOpenHelper {
/*
* creamos un objeto tipo SQLiteDataBase que es la referencia a la
* base de datos que estaremos gestionando, el contexto de la app
* la version de la base de datos que estamos utilizando y el nombre
* que le asignamos a la base de datos creada
*/
SQLiteDatabase bdControl;
Context thisContext;
private static final int VERSION_BASEDATOS = 1;
private static final String NAME_BD = "test.db";
public DataBase (Context context)
{
/*
* este constructor invoca al super constructor, inicializando nuestra clase, ahora
* podemos obtener la base de datos lista para modificar, insertar y eliminar registros.
*/
super(context,NAME_BD,null,VERSION_BASEDATOS);
bdControl = this.getWritableDatabase();
}
@Override
public void onCreate(SQLiteDatabase arg0)
{
/*
* el onCreate de la clase SQLiteOpenHelper crea la base de datos si no existe
*/
String createTable = "CREATE TABLE Nota (idReg INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, title TEXT, body TEXT);";
arg0.execSQL(createTable);
}
@Override
/*
* Este metodo, nos sirve para actualizar modificaciones en la base de datos
* no lo utilizaremos por el momento
*/
public void onUpgrade(SQLiteDatabase arg0, int arg1, int arg2) {
}
/*
* Crearemos métodos para poder insertar, modificar y eliminar, de manera transparente
* haciendo esta clase mas eficiente
*/
/*
* Este método nos devuelve un valor boleando explicando si tuvo exito el insert de un nuevo registro
* solo recibimos el titulo y el cuerpo, dentro del emtodo lo adaptamos al insert y lo ejecutamos en
* la base de datos activa, y el registro se insertará
*/
public boolean insertReg (String title, String body)
{
String query = "INSERT INTO Nota ( title , body) VALUES ('"+title+"', '"+body+"');";
boolean success = false;
try {
this.bdControl.execSQL(query);
success = true;
} catch (Exception e) {
success = false;
}
return success;
}
/*
* en este método se hará algo similar al insert, con la diferencia que vamos a actualizar los valores
* de un método ya existente, de igual forma regresa un valor boleano indicando si fue exitoso
* el intento de actualizar
*/
public boolean updateReg (String newTitle, String newBody, int idReg)
{
boolean success = false;
try {
if (newTitle != null) {
String SQL= "UPDATE Nota SET title='"+newTitle+"' WHERE idReg="+idReg;
bdControl.execSQL(SQL);
}
if (newBody != null) {
String SQL= "UPDATE Nota SET body='"+newBody+"' WHERE idReg="+idReg;
bdControl.execSQL(SQL);
}
success = true;
} catch (Exception e) {
success = false;
}
return success;
}
/*
* de nueva cuenta con el mismo estilo, este método elimina registros
* y nos devolverá si fue exitoso el query, este metodo recibe como parametro el identificador del registro
* para ubicarlo dentro de la base de datos y eliminarlo,
*
* Nota: en la buena practica los registros nunca se eliminan, solo se "desactivan" o "deshabilitan" pero esto
* es con fines de aprendizaje
*/
public boolean deleteReg (int idReg)
{
boolean success = false;
String query = "DELETE FROM Nota WHERE idReg =="+idReg+";";
try {
success = true;
bdControl.execSQL(query);
} catch (Exception e) {
success = false;
}
return success;
}
/*
* el siguiente método es un Select, que nos devuelve el contenido completo de UN registro
* recibiendo como parametro el id para identificarlo
*
* la clase ContentItem fue creada previamente.
*/
public ContentItem getReg (int idReg)
{
String query = "SELECT * FROM Nota WHERE idReg == "+idReg+";";
Cursor cursor = bdControl.rawQuery(query, null);
ContentItem item;
if(cursor.moveToFirst())
{
item = new ContentItem(cursor.getString(1), cursor.getString(2), cursor.getInt(0));
}
else {
item = null;
}
return item;
}
/*
* este método, nos devuelve una lista de elementos ContentItem (clase creada previamente)
* nos devuelve absolutamente todos los elementos insertados en la tabla
*/
public List<ContentItem> getAllReg ()
{
List<ContentItem> lista = new ArrayList<ContentItem>();
String query = "SELECT * FROM Nota";
Cursor cursor = bdControl.rawQuery(query, null);
if (cursor.moveToFirst())
{
do {
ContentItem currentItem = new ContentItem(cursor.getString(1), cursor.getString(2), cursor.getInt(0));
lista.add(currentItem);
} while (cursor.moveToNext());
}
else {
lista = null;
}
return lista;
}
}
Es muy trivial la manera de insertar y actualizar registros, si es conocemos los conceptos básicos de MySql, sin embargo los SELECT no son tan triviales, asi que explicaremos en breve en que consiste:
public ContentItem getReg (int idReg)
{
String query = "SELECT * FROM Nota WHERE idReg == "+idReg+";"; //creamos el Query
Cursor cursor = bdControl.rawQuery(query, null);/*ejecutamos el query asignandole el resultado a un objeto de tipo Cursor
este tipo de objeto, nos permite almacenar el resultado de una consulta*/
ContentItem item;
if(cursor.moveToFirst()) /*ponemos el cursor en el primer registro extraido, en este caso, solo es uno
pues el WHERE condicionando el ID nos dice que los ID no se repiten entonces solo habrá un resultado*/
{
item = new ContentItem(cursor.getString(1), cursor.getString(2), cursor.getInt(0));
/*con esta linea de código, estamos sacando los tipos de datos de cada registro, sin embargo, si pedimos un tipo
* int y es String, se creará una excepcion y la aplicación se detendrá, debemos de ser cuidadosos, con el tipo de dato
* que fue introducido en cada indice
*
* CREATE TABLE Nota (idReg INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, title TEXT, body TEXT);
* como se peude ver el primero (0) es un int y es el ID
* el segundo (1) es un String y es el titulo
* el tercero (2) es un String y es el cuerpo
*
* y asi indicamos segun el indice el tipo de dato, que vamos a obtener.
*
* en esta misma linea le asignamos los valores al constructor del objeto ContentItem y el objeto estará creado y listo
* para usarse, lo devolvemos como parametro.
*
* */
}
else {
item = null;
}
return item;
}
Bien ya que tenemos todos los elementos con las caracteristicas necesarias para lo que queremos hacer, vamos a integrar todo en nuestro activity principal, nuevamente, explico cada parte del código en forma de comentarios:
package com.example.sqliteandroid;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import BD.DataBase;
import android.os.Bundle;
import android.app.Activity;
import android.view.View;
import android.widget.AdapterView;
import android.widget.EditText;
import android.widget.ListView;
public class SQLiteActivity extends Activity {
/*
* Declaracion de variables necesarias para los widget de la interfaz
* una base de datos que la inicializaremos con la que hemos creado
* y un ID que sera el id del registro que se toca dentro del ListView
*/
ListView listView;
EditText editTitle, bodyText;
DataBase database;
Integer currentID;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_sqlite);
database = new DataBase(getApplicationContext()); /*es muy importante inicializar la base de datos al inicio de la
aplicación, pues si alguna consulta o query se intenta ejecutar, no habrá error, simplemente no se guardará nada
y no se obtendrá nada*/
initInterfaz();/*inicializamos la interfaz grafica*/
initListView();/*en este caso inicializaremos el ListView con un método aparte con un fin es especifico
cada que se inserte modifique o elimine un registro, necesitamos que eso se refleje en nuestra interfaz, entonces
tenemos que volver a llenar el LIstView, solo invocando a ese método*/
}
private void initInterfaz () /*simplemente inicializamos la interfaz*/
{
listView = (ListView) findViewById(R.id.listView);
editTitle = (EditText) findViewById(R.id.title);
bodyText = (EditText) findViewById(R.id.bodyText);
}
private void initListView ()
{
/*
* este método nos va a refrescar la vista del ListView, con nuestro adaptador personalizado
*/
currentID = 0;
/*
* ponemos el idActual en 0
*/
List<ContentItem> lista = database.getAllReg();
/*
* creamos un List de ContentItem y le asignamos los valores guardados en la base de datos, con el
* método correspondiente en la clase dataBase
*/
if (lista != null) {
/*
* en este momento la lista se inicializó correctamente con los valores de la Base de datos
* inicializamos el adapter personalizado y le agregamos el escuchador de clicks.
*/
MyAdapter adapter = new MyAdapter(getBaseContext(), lista);
listView.setAdapter(adapter);
listView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> arg0, View arg1, int arg2,
long arg3) {
/*
* al tocar sobre una celda, los datos que pertenecen a dicha celda se colocarán dentro de los editText
* recojiendo de la base de datos, por medio del ID con su método correspondiente en la base de datos
*/
currentID = (Integer) arg1.getTag();
int id = currentID;
ContentItem newContent = database.getReg(id);
editTitle.setText(newContent.getTitle());
bodyText.setText(newContent.getBodyText());
}
});
}
else {
/*
* En este momento la lista no se inicializó con los valores de la base de datos
* asi que inicializamos la lista con un arrayList y se lo enviamos al adaptador para que no
* muestra absolutamente nada.
*/
List<ContentItem> newList = new ArrayList<ContentItem>();
listView.setAdapter(new MyAdapter(getApplicationContext(), newList));
}
}
private boolean checkFields ()
{
/*
* Este método nos revisa que los TextFields, tengan texto.
*/
boolean success = false;
if (editTitle.length() > 0)
{
if (bodyText.length() > 0) {
success = true;
}
}
return success;
}
/*
* A cada botón creado se le asignó un método onClik dentro de la interfaz y en el XML tambien se puede ver
* ese método debe de estar definido para que pueda funcionar el botón con un método en especifico al toque
* aqui se muestra el método para cada botón creado.
*/
public void insert (View view)
{
/*
* Primero se comprueba que exista texto dentro de los campos editText
* Se inserta el registro en la base de datos
* con el método creado dentro de la clase DataBase
* y se refresca el ListView
*/
if (checkFields()) {
database.insertReg(editTitle.getText().toString(), bodyText.getText().toString());
initListView();
}
}
public void update (View view)
{
/*
* Primero se comprueba que exista texto dentro de los campos editText
* Se Actualiza el registro actual, con los valores dentro de los editText
* utilizando el metodo correspondiente dentro
* de la clase DataBase y se refresca el ListView
*/
if (currentID > 0 && checkFields()) {
database.updateReg(editTitle.getText().toString(), bodyText.getText().toString(), currentID);
initListView();
}
}
public void delete (View view)
{
/*
* Se elimina el registro actual, con el metodo correspondiente dentro de la clase DataBase
* se refresca el ListView, y eliminamos lo que exista dentro de los editText por limpieza visual.
*/
if (currentID > 0) {
database.deleteReg(currentID);
initListView();
editTitle.setText("");
bodyText.setText("");
}
}
}
Con esto, tendremos los resultados esperados, insertando y recuperando informacion en una base de datos, espero les sirva, les guste, y comenten algo, sea bueno o malo. Saludos a todos
