Portal Android - Comunidade de Desenvolvedores Android
http://www.portalandroid.org/comunidade/

[ARTIGO] Trabalhando com SQLite usando DroidPersistence
http://www.portalandroid.org/comunidade/viewtopic.php?f=7&t=9827
Página 1 de 1

Autor:  doug.cav@ig.com.br [ 21 Abr 2011, 15:51 ]
Assunto do Tópico:  [ARTIGO] Trabalhando com SQLite usando DroidPersistence

Introdução:

Olá,
Para quem já anda desenvolvendo em Java EE e passa a conhecer o Android, não consegue ficar sem comparar algumas vantagens de frameworks maduros para a plataforma JEE.
Uma destas vantagens é a feature que facilitou muito a integraçao com Banco de dados, a JPA: Java Persistence API. Nela é possível anotar em sua classe modelo, a visão da mesma na base de dados (Tabela, campos, chaves primárias, estrangeiras, etc..), permitindo que a classe DAO seja mais genérica e fácil de implementar, sem a necessidade de comandos DML (Data Manipulation Language) como INSERT, UPDATE, DELETE…

Um exemplo:

public static void insertEmployees()
 {
 Connection con = getConnection();

 String insertString1, insertString2, insertString3, insertString4;
 insertString1 = "insert into Employees values(6323, 'Hemanth')";
 insertString2 = "insert into Employees values(5768, 'Bob')";
 insertString3 = "insert into Employees values(1234, 'Shawn')";
 insertString4 = "insert into Employees values(5678, 'Michaels')";

try {
 stmt = con.createStatement();
 stmt.executeUpdate(insertString1);
 stmt.executeUpdate(insertString2);
 stmt.executeUpdate(insertString3);
 stmt.executeUpdate(insertString4);

 stmt.close();
 con.close();

 } catch(SQLException ex) {
 System.err.println("SQLException: " + ex.getMessage());
 }
 


Percebam que o comando de insert ficaria muito a cargo do implementador, claro que este pode ajustar para que receba o objeto correto e faça as devidas inserções. O problema é que, caso se crie um novo campo na tabela, este deve ser lembrado na classe DAO.

Agora percebam com JPA como é uma gravação do objeto:

EntityManagerFactory emf=Persistence.
createEntityManagerFactory("jpa");
EntityManager em=emf.createEntityManager();
try{
EntityTransaction entr=em.getTransaction();
entr.begin();
Employee emp = new Employee();
emp.setEmpName("Vinod Kumar");
emp.setEmpSalary(20000);
em.persist(emp);
entr.commit();
}
finally{
em.close();
}
 

Viram como o objeto EntityManager (em) só usou o método “persist” para gravar o objeto, pois é, este é o ganho de usar a JPA inicialmente.

Uma desvantagem é, ter de anotar as classes modelo corretamente para que a biblioteca que manipule a conexão com o banco de dados (Hibernate, Toplink, Eclipselink) entenda como deve ser feito o comando DML que é executado por ela.

Agora, voltando a falar sobre o Android, até hoje não temos dentro da SDK algo que facilite desta maneira. Apelando a biblioteca de terceiros, no caso o DroidPersistence, este poderá realizar operações semelhantes a JPA e/ou Hibernate, que por este é que a JPA surgiu…

O DroidPersistence prega a idéia que haja as classes modelo corretamente anotadas, a classe de definição de tabela (que é apenas uma herança) e a classe Dao (que é também outra herança). A partir daí, será possível realizar os comandos básicos para o banco relacional SQLite.

Vamos a mão na massa:

O DroidPersistence pede que o desenvolvedor não crie a tabela, não crie a instrução insert e sim apenas aponte qual o nome e campos dela na própria classe de modelo. Sendo assim, para aplicações com mais de uma tabela isto seja altamente viável.

Vamos ao nosso projeto: CATÁLOGO DE GAMES

O projeto irá consistir em:

Lista dos jogos
Cadastro dos jogos
Cadastro das plataformas dos Jogos

Crie uma aplicação Android com o nome “GamesLibrary”.

Para a tela principal, que irá listar os jogos cadastrados, edite a tela “main.xml”:


<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
 android:layout_width="fill_parent"
 android:layout_height="fill_parent" android:id="@+layout/main">


 <ListView android:id="@android:id/list" android:layout_width="fill_parent"
 android:layout_height="fill_parent" />

</LinearLayout>
 


Para a tela de novo jogo, cadastre uma nova tela xml com o nome: “newgame.xml”
Nesta tela insira os componentes:


<?xml version="1.0" encoding="utf-8"?>
<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:text="@string/newGame" android:id="@+id/textView1" android:layout_height="wrap_content" android:layout_width="fill_parent" android:layout_weight="1"></TextView>
 <TextView android:text="@string/Game_Name" android:layout_width="wrap_content" android:id="@+id/textView2" android:layout_height="wrap_content" android:layout_weight="1"></TextView>
 <EditText android:layout_width="fill_parent" android:layout_height="wrap_content" android:id="@+id/editGameName" android:text="@string/null_String" android:layout_weight="1"></EditText>
 <TextView android:text="@string/Game_Production" android:layout_width="wrap_content" android:id="@+id/textView3" android:layout_height="wrap_content" android:layout_weight="1"></TextView>
 <EditText android:id="@+id/editGameProduction" android:text="@string/null_String" android:layout_weight="1" android:layout_height="wrap_content" android:layout_width="fill_parent"></EditText>
 <TextView android:layout_width="wrap_content" android:id="@+id/textView4" android:layout_height="wrap_content" android:text="@string/Game_Platform"></TextView>
 <Spinner android:layout_width="fill_parent" android:layout_height="wrap_content" android:id="@+id/spinnerGamePlatform"></Spinner>
 <Button android:id="@+id/buttonSaveGame" android:layout_height="wrap_content" android:text="@string/Save" android:layout_width="fill_parent" android:layout_weight="1"></Button>
</LinearLayout>
 


A última tela será de cadastro das plataformas com o nome “platform.xml”:


<?xml version="1.0" encoding="utf-8"?>
<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:layout_width="wrap_content" android:id="@+id/textView1" android:layout_height="wrap_content" android:text="@string/Game_Platform"></TextView>
 <TextView android:layout_width="wrap_content" android:id="@+id/textView3" android:layout_height="wrap_content" android:text="@string/Game_Name"></TextView>
 <EditText android:layout_width="fill_parent" android:layout_height="wrap_content" android:id="@+id/editPlatformName" android:text="@string/null_String"></EditText>
 <TextView android:layout_width="wrap_content" android:id="@+id/textView2" android:layout_height="wrap_content" android:text="@string/Platform_Manufacturer"></TextView>
 <EditText android:layout_width="fill_parent" android:layout_height="wrap_content" android:id="@+id/editPlatformManufacturer" android:text="@string/null_String"></EditText>
 <Button android:id="@+id/buttonSavePlatform" android:layout_height="wrap_content" android:text="@string/Save" android:layout_width="fill_parent"></Button>
</LinearLayout>
 


Não se preocupem com as Strings (@string), estas podem ser substituídas por uma fixa.
Agora baixe o DroidPersistence e insira no BuildPath do seu projeto.
Vamos criar as classes model
Insira um pacote model no seu projeto (no caso o meu fica em: “br.com.gameslibrary.model”
Crie as classes:

GAME:

package br.com.gameslibrary.model;

import org.droidpersistence.annotation.Column;
import org.droidpersistence.annotation.ForeignKey;
import org.droidpersistence.annotation.Table;
import org.droidpersistence.model.BaseModel;

@Table(name="GAME")
public class Game extends BaseModel {

 @Column(name="TITLE")
 private String title;

 @Column(name="PRODUCTION")
 private String production;

 @Column(name="PLATFORM_ID")
 @ForeignKey(tableReference="PLATFORM", onDeleteCascade=true)
 private long platform_id;

 public String getTitle() {
 return title;
 }
 public void setTitle(String title) {
 this.title = title;
 }
 public String getProduction() {
 return production;
 }
 public void setProduction(String production) {
 this.production = production;
 }
 public long getPlatform_id() {
 return platform_id;
 }
 public void setPlatform_id(long platformId) {
 platform_id = platformId;
 }

}
 


Platform.java:

package br.com.gameslibrary.model;

import org.droidpersistence.annotation.Column;
import org.droidpersistence.annotation.Table;
import org.droidpersistence.model.BaseModel;

@Table(name="PLATFORM")
public class Platform extends BaseModel{

 @Column(name="NAME")
 private String name;

 @Column(name="MANUFACTURER")
 private String manufacturer;

 public Platform(String name, String manufacutrer){
 this.name = name;
 this.manufacturer = manufacutrer;
 }

 public Platform(){

 }

 public String getName() {
 return name;
 }
 public void setName(String name) {
 this.name = name;
 }
 public String getManufacturer() {
 return manufacturer;
 }
 public void setManufacturer(String manufacturer) {
 this.manufacturer = manufacturer;
 }

}
 


Repare que não há o campo ID nas tabelas, este é criado automaticamente pela classe herdada BaseModel e não deverá ser escrito na classe filha.
Até agora criamos as telas e as classes modelo, falta implementar as classes dao e as visualizações das telas criadas.

Até agora criamos as classes modelo para persistencia, informamos qual tabela e quais campos, resta-nos criar as implementações agora
Crie outros dois pacotes: “br.com.gameslibrary.dao.tabledefinition” e “br.com.gameslibrary.dao.impl”
No pacote tabledefinition crie a classe GameTableDefinition.java:

package br.com.gameslibrary.dao.tabledefinition;

import org.droidpersistence.dao.TableDefinition;

import br.com.gameslibrary.model.Game;

public class GameTableDefinition extends TableDefinition<Game>{

 public GameTableDefinition() {
 super(Game.class);
 }
}
 


Esta classe é responsável por montar a tabela, ou seja, montar a especificação para o SQLite como o comando CREATE TABLE.
Faça o mesmo com a classe nova PlatformTableDefinition.java;

No pacote “dao.impl” crie a classe GameDao.java:

package br.com.gameslibrary.dao.impl;

import org.droidpersistence.dao.DroidDao;
import org.droidpersistence.dao.TableDefinition;

import android.database.sqlite.SQLiteDatabase;
import br.com.gameslibrary.model.Game;

public class GameDao extends DroidDao<Game> {

 public GameDao(TableDefinition<Game> tableDefinition, SQLiteDatabase database) {
 super(Game.class, tableDefinition, database);
 }
}
 


Esta classe é responsável por realizar os comandos de insert, delete, get, update, list.
Faça também para a classe Platform.java com o nome PlatformDao.java;

A classe OpenHelper:

Dentro do pacote “br.com.gameslibrary.dao” crie a classe OpenHelper conforme abaixo:

package br.com.gameslibrary.dao;

import br.com.gameslibrary.dao.tabledefinition.GameTableDefinition;
import br.com.gameslibrary.dao.tabledefinition.PlatformTableDefinition;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.database.sqlite.SQLiteDatabase.CursorFactory;

public class OpenHelper extends SQLiteOpenHelper {

 public OpenHelper(Context context, String name, CursorFactory factory,
 int version) {
 super(context, name, factory, version);
 }

 @Override
 public void onOpen(SQLiteDatabase db) {
 super.onOpen(db);
 if (!db.isReadOnly()) {
 db.execSQL("PRAGMA foreign_keys=ON;");
 Cursor c = db.rawQuery("PRAGMA foreign_keys", null);
 if (c.moveToFirst()) {
 int result = c.getInt(0);
 }
 if (!c.isClosed()) {
 c.close();
 }
 }
 }

 @Override
 public void onCreate(SQLiteDatabase db) {
 try{
 PlatformTableDefinition platformTableDefinition = new PlatformTableDefinition();
 platformTableDefinition.onCreate(db);

 GameTableDefinition gameTableDefinition = new GameTableDefinition();
 gameTableDefinition.onCreate(db);
 }catch(Exception e){
 e.printStackTrace();
 }
 }

 @Override
 public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
 try{
 PlatformTableDefinition platformTableDefinition = new PlatformTableDefinition();
 platformTableDefinition.onUpgrade(db, oldVersion, newVersion);

 GameTableDefinition gameTableDefinition = new GameTableDefinition();
 gameTableDefinition.onUpgrade(db, oldVersion, newVersion);
 }catch(Exception e){
 e.printStackTrace();
 }

 }

}
 

Esta classe é responsável por criar o banco de dados e a conexão com o mesmo.
Vamos a última classe de manipulação de dados: DataManager.java

Esta classe pode estar no pacote “dao” como a OpenHelper.java e deverá seguir a estrutura:

package br.com.gameslibrary.dao;

import java.util.List;

import br.com.gameslibrary.dao.OpenHelper;
import br.com.gameslibrary.dao.impl.GameDao;
import br.com.gameslibrary.dao.impl.PlatformDao;
import br.com.gameslibrary.dao.tabledefinition.GameTableDefinition;
import br.com.gameslibrary.dao.tabledefinition.PlatformTableDefinition;
import br.com.gameslibrary.model.Game;
import br.com.gameslibrary.model.Platform;
import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.os.Environment;
import android.os.SystemClock;

public class DataManager {

 private Context context;
 private SQLiteDatabase database;
 private GameDao gameDao;
 private PlatformDao platformDao;

 public DataManager(Context context){
 setContext(context);
 SQLiteOpenHelper openHelper = new OpenHelper(context, "GAMEDATABASE", null, 2);
 setDatabase(openHelper.getWritableDatabase());

 this.platformDao = new PlatformDao(new PlatformTableDefinition(), database);
 this.gameDao = new GameDao(new GameTableDefinition(), database);
 }

 private void openDb(){
 if(! getDatabase().isOpen()){
 setDatabase(SQLiteDatabase.openDatabase(Environment.getDataDirectory() + "/data/br.com.gamedatabase/databases/gamedatabase.db", null, SQLiteDatabase.OPEN_READWRITE));
 }
 }

 private void closeDb() {
 if (getDatabase().isOpen()) {
 getDatabase().close();
 }
 }

 private void resetDb() {
 closeDb();
 SystemClock.sleep(500);
 openDb();
 }

 public Game getGame(Long id){
 return getGameDao().get(id);
 }

 public Platform getPlatform(Long id){
 return getPlatformDao().get(id);
 }

 public Platform getPlatformByName(String name){
 return getPlatformDao().getByClause(" NAME ='"+name+"'", null, null, null, "1");
 }

 public List<Game> getGameList(){
 return getGameDao().getAll();
 }

 public List<Platform> getPlatformList(){
 return getPlatformDao().getAll();
 }

 public boolean deleteGame(Long id){
 boolean result = false;
 getDatabase().beginTransaction();
 result = getGameDao().delete(id.intValue());
 getDatabase().setTransactionSuccessful();
 getDatabase().endTransaction();
 return result;
 }

 public boolean deletePlatform(Long id){
 boolean result = false;
 getDatabase().beginTransaction();
 result = getPlatformDao().delete(id.intValue());
 getDatabase().setTransactionSuccessful();
 getDatabase().endTransaction();
 return result;
 }

 public long saveGame(Game game){
 long result = 0;
 try {
 getDatabase().beginTransaction();
 result = getGameDao().save(game);
 getDatabase().setTransactionSuccessful();
 } catch (Exception e) {
 e.printStackTrace();
 }
 getDatabase().endTransaction();
 return result;
 }

 public long savePlatform(Platform platform){
 long result = 0;
 try {
 getDatabase().beginTransaction();
 result = getPlatformDao().save(platform);
 getDatabase().setTransactionSuccessful();
 } catch (Exception e) {
 e.printStackTrace();
 }
 getDatabase().endTransaction();
 return result;
 }

 public boolean updateGame(Game game){
 boolean result = false;
 try {
 getDatabase().beginTransaction();
 getGameDao().update(game, game.getId());
 getDatabase().setTransactionSuccessful();
 result = true;
 } catch (Exception e) {
 e.printStackTrace();
 }
 getDatabase().endTransaction();
 return result;
 }

 public boolean updatePlatform(Platform platform){
 boolean result = false;
 try {
 getDatabase().beginTransaction();
 getPlatformDao().update(platform, platform.getId());
 getDatabase().setTransactionSuccessful();
 result = true;
 } catch (Exception e) {
 e.printStackTrace();
 }
 getDatabase().endTransaction();
 return result;
 }

 public Context getContext() {
 return context;
 }
 public void setContext(Context context) {
 this.context = context;
 }
 public SQLiteDatabase getDatabase() {
 return database;
 }
 public void setDatabase(SQLiteDatabase database) {
 this.database = database;
 }
 public GameDao getGameDao() {
 return gameDao;
 }
 public void setGameDao(GameDao gameDao) {
 this.gameDao = gameDao;
 }

 public PlatformDao getPlatformDao() {
 return platformDao;
 }

 public void setPlatformDao(PlatformDao platformDao) {
 this.platformDao = platformDao;
 }

}
 

A classe DataManager é o coração da manipulação com os dados, é nela que buscaremos os objetos retornados, iremos inserir, atualizar e excluir os Games e Plataformas.

Por fim, vamos interagir com os objetos no banco de dados:
Crie na raiz do projeto (pacote “br.com.gameslibrary”) a classe GamesLibraryApp.java:

package br.com.gameslibrary;

import br.com.gameslibrary.dao.DataManager;
import android.app.Application;

public class GamesLibraryApp extends Application {

 private DataManager dataManager;

 @Override
 public void onCreate() {
 super.onCreate();
 setDataManager(new DataManager(this));
 }

 @Override
 public void onTerminate() {
 // TODO Auto-generated method stub
 super.onTerminate();
 }

 public DataManager getDataManager() {
 return dataManager;
 }

 public void setDataManager(DataManager dataManager) {
 this.dataManager = dataManager;
 }

}
 

Esta classe tem o propósito de ser o “runtime” da aplicação, ou seja, esta pode ser chamada para instanciar objetos durante a sessão.
Lista de jogos:

Na classe GamesLibrary.java implemente:

package br.com.gameslibrary;

import java.util.ArrayList;
import java.util.List;

import br.com.gameslibrary.model.Game;

import android.app.ListActivity;
import android.content.Intent;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.widget.ArrayAdapter;
import android.widget.ListView;

public class GamesLibrary extends ListActivity {
 /** Called when the activity is first created. */

 private static final int OPTIONS_MENU_SEARCH = 0;
 private static final int OPTIONS_MENU_NEW = 1;
 private static final int OPTIONS_MENU_DELETE = 2;
 private static final int OPTIONS_MENU_ABOUT = 3;

 private GamesLibraryApp gamesLibraryApp;
 private List<Game> games;
 private ArrayAdapter<String> adapter;

 @Override
 public void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.main);

 gamesLibraryApp = (GamesLibraryApp) getApplication();

 ListView listView = getListView();

 games = new ArrayList<Game>();

 games = gamesLibraryApp.getDataManager().getGameList();

 List<String> resultset = new ArrayList<String>();
 for (int i = 0; i < games.size() ; i++){
 resultset.add(games.get(i).getTitle());
 }

 adapter = new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1 , resultset);

 listView.setAdapter(adapter);
 }

 @Override
 public boolean onCreateOptionsMenu(Menu menu) {

 menu.add(0, OPTIONS_MENU_SEARCH, 0, "Search");
 menu.add(0, OPTIONS_MENU_NEW, 0, "New");
 menu.add(0, OPTIONS_MENU_DELETE, 0, "Delete");
 menu.add(0, OPTIONS_MENU_ABOUT, 0, "About");

 return true;
 }

 @Override
 public boolean onOptionsItemSelected(MenuItem item) {
 switch (item.getItemId()) {
 case OPTIONS_MENU_NEW:
 startActivity(new Intent(this, NewGame.class));
 break;
 case OPTIONS_MENU_SEARCH:
 //BUSCA
 break;
 }
 return false;
 }

}
 

Perceba que para retornar a lista de games foi só necessário a linha de código -> “games = gamesLibraryApp.getDataManager().getGameList();”. O comando GetDataManager traz o datamanager instanciado dentro da sessão e nele há o método do banco de dados que faz a busca de todos os games no formato de ArrayList<Game>

Novo Jogo (NewGame.java):

package br.com.gameslibrary;

import java.util.ArrayList;
import java.util.List;

import br.com.gameslibrary.model.Game;
import br.com.gameslibrary.model.Platform;
import android.app.Activity;
import android.app.AlertDialog;
import android.content.Intent;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Spinner;

public class NewGame extends Activity {

 private GamesLibraryApp gamesLibraryApp;
 private EditText editName;
 private EditText editProduction;
 private Button buttonSave;
 private Spinner spinnerPlatform;
 private List<Platform> platforms;
 private ArrayAdapter<String> adapterPlatforms;

 private static final int OPTIONS_MENU_NEWPLATFORM = 1;

 @Override
 protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 super.setContentView(R.layout.newgame);

 gamesLibraryApp = (GamesLibraryApp) getApplication();
 editName = (EditText) findViewById(R.id.editGameName);
 editProduction = (EditText) findViewById(R.id.editGameProduction);
 buttonSave = (Button) findViewById(R.id.buttonSaveGame);
 spinnerPlatform = (Spinner) findViewById(R.id.spinnerGamePlatform);

 platforms = new ArrayList<Platform>();

 platforms = gamesLibraryApp.getDataManager().getPlatformList();

 if(platforms.size() > 0){
 String[] resultset = new String[platforms.size()];
 for (int i = 0; i < platforms.size() ; i++){
 resultset[i]= platforms.get(i).getName();
 }

 adapterPlatforms = new ArrayAdapter(this, android.R.layout.simple_spinner_item , resultset);
 spinnerPlatform.setAdapter(adapterPlatforms);
 }

 buttonSave.setOnClickListener(new View.OnClickListener() {

 @Override
 public void onClick(View v) {
 String result = "";
 Game game = new Game();
 game.setTitle(editName.getText().toString());
 game.setProduction(editProduction.getText().toString());

 game.setPlatform_id(gamesLibraryApp.getDataManager().getPlatformByName(spinnerPlatform.getSelectedItem().toString()).getId());

 AlertDialog.Builder dialog = new AlertDialog.Builder(NewGame.this);
 dialog.setTitle("Message");

 try{
 if (gamesLibraryApp.getDataManager().saveGame(game) > 0){
 result = "Game saved!";
 }
 }catch(Exception e){
 e.printStackTrace();
 result = "Game not saved!";
 }finally{
 dialog.setMessage(result);
 dialog.setNeutralButton("OK", null);
 dialog.show();
 }
 }
 });

 }

 @Override
 public boolean onCreateOptionsMenu(Menu menu) {
 menu.add(0, OPTIONS_MENU_NEWPLATFORM, 0, "New Platform");
 return true;
 }

 @Override
 public boolean onOptionsItemSelected(MenuItem item) {
 switch (item.getItemId()) {
 case OPTIONS_MENU_NEWPLATFORM:
 startActivity(new Intent(this, PlatformView.class));
 break;
 }
 return false;
 }
}
 


No trecho:

Game game = new Game();
 game.setTitle(editName.getText().toString());
 game.setProduction(editProduction.getText().toString());

 game.setPlatform_id(gamesLibraryApp.getDataManager().getPlatformByName(spinnerPlatform.getSelectedItem().toString()).getId());
 

É construído o objeto para poder ser salvo dentro do Manager.

Por fim a classe da tela de plataformas:

package br.com.gameslibrary;

import br.com.gameslibrary.model.Platform;
import android.app.Activity;
import android.app.AlertDialog;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;

public class PlatformView extends Activity {

 private GamesLibraryApp gamesLibraryApp;
 private EditText editName;
 private EditText editManufacturer;
 private Button save;

 @Override
 protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.platform);

 gamesLibraryApp = (GamesLibraryApp) getApplication();
 save = (Button) findViewById(R.id.buttonSavePlatform);
 editName = (EditText) findViewById(R.id.editPlatformName);
 editManufacturer = (EditText) findViewById(R.id.editPlatformManufacturer);

 save.setOnClickListener(new View.OnClickListener() {

 @Override
 public void onClick(View v) {
 String result = "";
 Platform platform = new Platform();
 platform.setName(editName.getText().toString());
 platform.setManufacturer(editManufacturer.getText().toString());

 AlertDialog.Builder dialog = new AlertDialog.Builder(PlatformView.this);
 dialog.setTitle("Message");

 try{
 if (gamesLibraryApp.getDataManager().savePlatform(platform) > 0){
 result = "PlatForm saved!";
 }
 }catch(Exception e){
 e.printStackTrace();
 result = "PlatForm not saved!";
 }finally{
 dialog.setMessage(result);
 dialog.setNeutralButton("OK", null);
 dialog.show();
 }

 }
 });
 }
}
 


Pronto, até agora conseguimos listar na primeira tela e cadastrar games e plataformas, implemente também a atualização, exclusão e busca mediante o DataManager.

Conclusão:

Com o DroidPersistence deve ser seguido a risca algumas regras de anotação e padronização de classes, porém, quando há esta padronização não há necessidade de retrabalho em classes DAO, permitindo maior tempo em outras funções de sua aplicação, ou folga \o/.

Ainda não sei medir ao certo quando vale a pena usar classes que implementam a persistencia ou “fazer na mão” estas operações. Mas o propósito é sempre evitar trabalhos repetitivos e volumosos, segue abaixo uma tabela comparativa do uso de comandos em classes de dados manualmente X DroidPersistence:

Operação Model Manual DroidPersistence
Linhas para OnCreate()-------------------------------13-------------------2
Linhas para OnUpgrade()-----------------------------14--------------------2
Linhas para Save()-----------------------------------11-------------------1
Linhas para Delete()----------------------------------2--------------------1
Linhas para Get()-------------------------------------7--------------------1
Linhas para Update()---------------------------------11-------------------1
Classes para Criar Dao-------------------------------0 ou 1----------------1
Classes para Definição de Tabela---------------------0 ou 1----------------1
Quando modificar tabela tenho que modificar o Dao?---Sim-----------------Não

Abaixo os Downloads:
DroidPersistence
Código fonte do GamesLibrary

Autor:  jijo [ 22 Abr 2011, 11:13 ]
Assunto do Tópico:  Re: Trabalhando com SQLite usando DroidPersistence

muito bom o artigo!

Autor:  samuel.cavanieri [ 25 Abr 2011, 02:33 ]
Assunto do Tópico:  Re: Trabalhando com SQLite usando DroidPersistence

parabéns doug.cav!

Gostei do DroidPersistense!

Autor:  vini.durlo [ 04 Mai 2011, 18:11 ]
Assunto do Tópico:  Re: Trabalhando com SQLite usando DroidPersistence

ótimo artigo!

Autor:  victorapc [ 31 Mai 2011, 17:10 ]
Assunto do Tópico:  Re: Trabalhando com SQLite usando DroidPersistence

Ótimo artigo. Vai ajudar muito a solucionar varias duvidas.

Autor:  douglas.costa [ 15 Mar 2012, 17:07 ]
Assunto do Tópico:  Re: [ARTIGO] Trabalhando com SQLite usando DroidPersistence

doug, estou com problemas na classe BaseModel, "extends BaseModel", nao consigo usar o extends nela, de onde vc importa essa classe?? ja tentei varios import mas o erro nela persiste.

Autor:  doug.cav@ig.com.br [ 15 Mar 2012, 21:43 ]
Assunto do Tópico:  Re: [ARTIGO] Trabalhando com SQLite usando DroidPersistence

Ow meu chará Douglas, talvez vc já tenha em mãos a versão 2.1, nela não é mais necessário extender suas classes de basemodel, porém, vc terá de criar seu atributo pk e anotá-lo com @id. Fiz isso pois algumas PKs não são só integer, veja o exemplo na página principal do projeto.

Também estou tentando trabalhar em PK composta mas o tempo para isso está complicado :[


[]s e boa sorte!

Autor:  douglas.costa [ 16 Mar 2012, 02:54 ]
Assunto do Tópico:  Re: [ARTIGO] Trabalhando com SQLite usando DroidPersistence

Olá Douglas, hehehe, entendi, então quanto a isso estou tranquilo, problema resolvido, obrigado, abraços..

Autor:  douglas.costa [ 11 Abr 2012, 15:34 ]
Assunto do Tópico:  Re: [ARTIGO] Trabalhando com SQLite usando DroidPersistence

Douglas beleza?

para mim poder usar o moveToNext e moveToPrevius no droidpersistence, vc tem alguma ideia de como pode ser feito, vi um exemplo usando Cursor, que nao é o meu caso pq uso o droidpersistence, vc teria alguma sujestao para isso?

Obrigado

Autor:  doug.cav@ig.com.br [ 12 Abr 2012, 02:06 ]
Assunto do Tópico:  Re: [ARTIGO] Trabalhando com SQLite usando DroidPersistence

E ai Chará,

como o droidpersistence mantém a camada de Cursors retornando List<Object> vc irá iterar sobre a lista retornada pelos comandos de listAll e listAllByClause para iterar na lista vc poderá fazer algum for ou algum get(indice) para próximo ou anterior.

Espero ter ajudado.

Autor:  douglas.costa [ 23 Jul 2012, 13:08 ]
Assunto do Tópico:  Re: [ARTIGO] Trabalhando com SQLite usando DroidPersistence

Olá douglas, caso eu queira excluir meu banco(já criado e populado) e cria-lo novamente em tempo de execução, como eu poderia fazer isso, seria so chamar o metodo :

private void resetDb() {
 closeDb();
 SystemClock.sleep(500);
 openDb();
 }

Autor:  douglas.costa [ 01 Ago 2012, 11:29 ]
Assunto do Tópico:  Re: [ARTIGO] Trabalhando com SQLite usando DroidPersistence

douglas blz? Tenho uma tabela aqui que no caso tera que ser chave composta, eu uso o
@PrimaryKey
sobre os 2 campos que sera a chave? Obrigado!

Autor:  virmerson [ 26 Fev 2013, 18:23 ]
Assunto do Tópico:  Re: [ARTIGO] Trabalhando com SQLite usando DroidPersistence

Olá, parabéns pelo artigo! estou realizando os testes com o DroidPersistence 2.1.3 e neste versão não há a classe org.droidpersistence.model.BaseModel.
Teria uma similar ou não há mais necessidade?

Página 1 de 1 Todos os Horários estão como UTC - 2 horas [ DST ]
Powered by phpBB © 2000, 2002, 2005, 2007 phpBB Group
http://www.phpbb.com/