Como usar banco de dados em uma aplicação Android

Um dos grandes diferenciais da plataforma android é a grande quantidade de módulos e APIs que as aplicações tem à  disposição para usar. Eles dão muito poder ao desenvolvedores, permitindo que estes façam coisas que eram impossíveis em outras plataformas móveis.

Um dos mais importantes módulos é o SQLite. Sim, amigos, já temos um SGDB (Sistema gerenciador de bancos de dados) instalado e pronto para usar! E é exatamente o que faremos no artigo de hoje.

Usaremos o content provider para acessar o banco de dados.

Para fazer isso, precisamos implementar os métodos da classe ContentProvider que vimos no artigo passado (query(), delete(), update(), etc…)  para prover ao usuário os métodos para criar, atualizar, deletar e recuperar os dados. Além disso, usaremos a classe SQLiteOpenHelper para gerenciar a conexão com o banco de dados.

A classe SQLiteOpenHelper

A classe SQLiteOpenHelper, como dito anteriormente, será usada para gerenciar o banco de dados. Para usá-la, é preciso criar uma subclasse implementando os métodos abaixo:

• onCreate() – Este método é chamado quando a conexão com o banco de dados for aberta pela primeira vez. É aqui que criaremos o banco de dados, com o comando sql CREATE.
• onUpdate() – Este método é chamado quando a versão do banco de dados muda. Por exemplo, digamos que você criou uma nova versão de seu aplicativo que usa uma tabela a mais no banco de dados. Quando esta nova versão for instalada (em um telefone que já possuir a primeira versão) este método será chamado, então você poderá criar apenas a nova  tabela, mantendo os dados do usuário.

O código

O código do QuickNotesProvider fica assim, acessando o banco de dados. A seguir, eu explico algumas coisas que podem gerar dúvidas.

view plaincopy to clipboardprint?

1. package br.com.felipesilveira.quicknotes;  
2.   
3. import java.util.HashMap;  
4.   
5. import android.content.ContentProvider;  
6. import android.content.ContentUris;  
7. import android.content.Context;  
8. import android.content.UriMatcher;  
9. import android.net.Uri;  
10. import android.provider.BaseColumns;  
11. import android.content.ContentValues;  
12. import android.database.Cursor;  
13. import android.database.sqlite.SQLiteDatabase;  
14. import android.database.sqlite.SQLiteOpenHelper;  
15. import android.database.sqlite.SQLiteQueryBuilder;  
16.   
17. public class QuickNotesProvider extends ContentProvider {  
18.   
19.     // Authority do nosso provider, a ser usado nas Uris.  
20.     public static final String AUTHORITY =   
21.         "br.com.felipesilveira.quicknotes.quicknotesprovider";  
22.       
23.     // Nome do arquivo que irá conter o banco de dados.  
24.     private static  final String DATABASE_NAME = "quicknotes.db";  
25.       
26.     // Versao do banco de dados.  
27.     // Este valor é importante pois é usado em futuros updates do DB.  
28.     private static  final int  DATABASE_VERSION = 1;  
29.       
30.     // Nome da tabela que irá conter as anotações.  
31.     private static final  String NOTES_TABLE = "notes";  
32.   
33.     // 'Id' da Uri referente às notas do usuário.  
34.     private  static final int NOTES = 1;  
35.   
36.     // Tag usada para imprimir os logs.  
37.     public static final String TAG = "QuickNotesProvider";  
38.       
39.     // Instância da classe utilitária  
40.     private DBHelper mHelper;  
41.       
42.     // Uri matcher - usado para extrair informações das Uris  
43.     private static final UriMatcher mMatcher;  
44.   
45.     private static HashMap<string, string=""> mProjection;  
46.       
47.     static {  
48.         mProjection = new HashMap<string, string="">();  
49.         mProjection.put(Notes.NOTE_ID, Notes.NOTE_ID);  
50.         mProjection.put(Notes.TEXT, Notes.TEXT);      
51.     }  
52.       
53.     static {  
54.         mMatcher = new UriMatcher(UriMatcher.NO_MATCH);  
55.         mMatcher.addURI(AUTHORITY, NOTES_TABLE, NOTES);  
56.     }  
57.       
58.       
59.     /////////////////////////////////////////////////////////////////  
60.     //           Métodos overrided de ContentProvider              //  
61.     /////////////////////////////////////////////////////////////////  
62.     @Override  
63.     public int delete(Uri uri, String selection, String[] selectionArgs) {  
64.         SQLiteDatabase db = mHelper.getWritableDatabase();  
65.         int count;  
66.         switch (mMatcher.match(uri)) {  
67.             case NOTES:  
68.                 count = db.delete(NOTES_TABLE, selection, selectionArgs);  
69.                 break;  
70.             default:  
71.                 throw new IllegalArgumentException(  
72.                   "URI desconhecida " + uri);  
73.         }  
74.        
75.         getContext().getContentResolver().notifyChange(uri, null);  
76.         return count;  
77.     }  
78.   
79.     @Override  
80.     public String getType(Uri uri) {  
81.             switch (mMatcher.match(uri)) {  
82.                 case NOTES:  
83.                     return Notes.CONTENT_TYPE;  
84.                 default:  
85.                     throw new IllegalArgumentException(  
86.                         "URI desconhecida " + uri);  
87.             }  
88.     }  
89.   
90.     @Override  
91.     public Uri insert(Uri uri, ContentValues values) {  
92.         switch (mMatcher.match(uri)) {  
93.             case NOTES:  
94.                 SQLiteDatabase db = mHelper.getWritableDatabase();  
95.                 long rowId = db.insert(NOTES_TABLE, Notes.TEXT, values);  
96.                 if (rowId > 0) {  
97.                     Uri noteUri = ContentUris.withAppendedId(  
98.                                  Notes.CONTENT_URI, rowId);  
99.                     getContext().getContentResolver().notifyChange(  
100.                                  noteUri, null);  
101.                     return noteUri;  
102.                 }  
103.             default:  
104.                 throw new IllegalArgumentException(  
105.                         "URI desconhecida " + uri);  
106.         }  
107.     }  
108.   
109.     @Override  
110.     public boolean onCreate() {  
111.         mHelper = new DBHelper(getContext());;  
112.         return true;  
113.     }  
114.   
115.     @Override  
116.     public Cursor query(Uri uri, String[] projection, String selection,  
117.             String[] selectionArgs, String sortOrder) {  
118.             // Aqui usaremos o SQLiteQueryBuilder para construir  
119.             // a query que será feito ao DB, retornando um cursor  
120.             // que enviaremos à aplicação.  
121.             SQLiteQueryBuilder builder = new  SQLiteQueryBuilder();  
122.             SQLiteDatabase database = mHelper.getReadableDatabase();  
123.             Cursor cursor;  
124.             switch (mMatcher.match(uri)) {  
125.                 case NOTES:  
126.                     // O Builer receberá dois parametros: a tabela  
127.                     // onde será feita a busca, e uma projection -   
128.                     // que nada mais é que uma HashMap com os campos  
129.                     // que queremos recuperar do banco de dados.  
130.                     builder.setTables(NOTES_TABLE);  
131.                     builder.setProjectionMap(mProjection);  
132.                     break;  
133.        
134.                 default:  
135.                     throw new IllegalArgumentException(  
136.                           "URI desconhecida " + uri);  
137.             }  
138.    
139.             cursor = builder.query(database, projection, selection,   
140.              selectionArgs, null, null, sortOrder);  
141.   
142.             cursor.setNotificationUri(getContext().getContentResolver(), uri);  
143.             return cursor;  
144.     }  
145.   
146.     @Override  
147.     public int update(Uri uri, ContentValues values, String selection,  
148.             String[] selectionArgs) {  
149.             SQLiteDatabase db = mHelper.getWritableDatabase();  
150.             int count;  
151.             switch (mMatcher.match(uri)) {  
152.                 case NOTES:  
153.                     count = db.update(NOTES_TABLE, values,   
154.                                                      selection, selectionArgs);  
155.                     break;     
156.                 default:  
157.                     throw new IllegalArgumentException(  
158.                             "URI desconhecida " + uri);  
159.             }  
160.        
161.             getContext().getContentResolver().notifyChange(uri, null);  
162.             return count;  
163.     }  
164.       
165.     /////////////////////////////////////////////////////////////////  
166.     //                Inner Classes utilitárias                    //  
167.     /////////////////////////////////////////////////////////////////  
168.     public static final class  Notes implements  BaseColumns {  
169.         public static final Uri CONTENT_URI = Uri.parse("content://"  
170.                     + QuickNotesProvider.AUTHORITY + "/notes");  
171.        
172.         public static final String CONTENT_TYPE =   
173.                 "vnd.android.cursor.dir/" + QuickNotesProvider.AUTHORITY;  
174.        
175.         public static final String NOTE_ID = "_id";  
176.        
177.         public static final String TEXT = "text";  
178.     }  
179.       
180.     private static class DBHelper extends SQLiteOpenHelper {  
181.        
182.         DBHelper(Context context) {  
183.             super(context, DATABASE_NAME, null, DATABASE_VERSION);  
184.         }  
185.        
186.         /* O método onCreate é chamado quando o provider é executado pela 
187.          * primeira vez, e usado para criar as tabelas no database 
188.          */  
189.         @Override  
190.         public void onCreate(SQLiteDatabase db) {  
191.             db.execSQL("CREATE TABLE " + NOTES_TABLE + " (" +   
192.                     Notes.NOTE_ID + " INTEGER PRIMARY KEY AUTOINCREMENT," +   
193.                     Notes.TEXT + " LONGTEXT" + ");");  
194.         }  
195.               
196.         /* O método onUpdate é invocado quando a versão do banco de dados 
197.          * muda. Assim, é usado para fazer adequações para a aplicação 
198.          * funcionar corretamente. 
199.          */    
200.         @Override  
201.         public void onUpgrade(SQLiteDatabase db,   
202.                                       int oldVersion, int newVersion) {  
203.             // Como ainda estamos na primeira versão do DB,  
204.             // não precisamos nos preocupar com o update agora.  
205.         }  
206.     }  
207. }  
208.   
209. </string,></string,>  

Cursores

O primeiro conceito importante a se falar é o conceito dos Cursores. Como você deve percebido, este é o tipo de retorno do método query(), e não é por acaso: Os cursores são “apontadores de dados” do banco de dados – ou seja, uma interface que permite o acesso aos dados retornados pela query enviada pelo usuário.

notifyChanges()

Em todos os métodos em que alteramos o banco de dados (inserimos, deletamos ou modificamos dados) é importante chamar o método modifyChanges(). Isso fará com que as aplicações que estejam utilizando este conjunto de dados sejam notificadas, permitindo a estas atualizar também os dados mostrados ao usuário.

Fonte(felipsilveira)