No seguinte artigo irei descrever todos os passos necessários para a criação de uma aplicação Android utilizando o Couchbase Lite na IDE Eclipse.
Se você ainda não conhece o Couchbase Lite, sugiro que de uma olhada no artigo que postei anteriormente.
Primeiro Passo: Criação do Projeto
1 - Abra o Eclipse e vá em File > New > Android Application Project.
2 - Com a janela de criação do projeto aberta entre com o nome da aplicação, nome do pacote, localização do projeto e as informações da versão do SDK.
3 - Clique em avançar e siga todas as etapas até o final, adicionando suas configurações (ou apenas aceite os padrões). Quando chegar até a última tela, clique em Finalizar.
4 - Agora abra o arquivo AndroidManifest.xml (localizado na raiz do seu projeto), e adicione a seguinte linha:
<uses-permission android:name="android.permission.INTERNET"/>
Seu arquivo deverá ficar parecido com o seguinte:
5 - Salve o arquivo AndroidManifest.xml.
Segundo Passo: Adicionando as Bibliotecas
1 - Baixe a última versão do Couchbase Lite para Android
2 - Extraia o arquivo baixado e copie todos os arquivos para a pasta libs do seu projeto.
3 - Baixe o seguinte Arquivo, e assim que o download terminar o renomeie para td_collator_so.zip.
4 - Extraia o arquivo td_collator_so.zip e copie os arquivos extraidos para a pasta libs do seu projeto, ao ser extraído o arquivo conterá três pastas:
5 - Após a adição de todas as bibliotecas, sua pasta libs deverá estar parecida com a seguinte:
6 - Clique em Run (você deverá ter o emulador já configurado) e verifique se a aplicação iniciou sem nenhum problema. A tela inicial será parecida com a seguinte:
Terceiro Passo: Criando Gerenciador e o Banco de Dados
Dentro de seu Activity principal (no meu caso MainActivity) iremos inserir os seguintes métodos:
private Database criarDatabase(Context context) {
Manager manager;
Database database = null;
try {
// Cria um manager para o banco de dados
manager = new Manager(context.getFilesDir(), Manager.DEFAULT_OPTIONS);
Log.d(TAG, "Manager criado com sucesso.");
// Cria o banco de dados
database = manager.getDatabase(DATABASE_NAME);
Log.d(TAG, "Database criado com sucesso.");
} catch (Exception e) {
handleException("Não foi possível criar o Manager ou o Database. Causa: ", e);
}
return database;
}
O método criarDatabase recebe como parâmetro o contexto da aplicação e retorna um objeto do tipo Database.
Dentro do método realizamos uma instancia do objeto Manager e passamos como parâmetro o caminho dos arquivos da aplicação e suas opções (Nesse caso usamos as opções padrões).
Abaixo utilizamos o getDatabase do Manager passando como parametro o nome do banco de dados a ser chamado. Caso o banco referenciado ainda não exista o Manager irá realizar a criação de um novo.
Após isso realizamos uma chamada ao método criarDatabase dentro do método onCreate da Activity:
Inicie a aplicação e você deverá ter o seguinte resultado no LOG:
Quarto Passo: Operações CRUD
Atualize o método onCreate da Activity para conter as seguintes chamadas:
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// Cria o banco de dados
Database db = criarDatabase(this);
// Grava um documento e retorna seu ID
String idDocumento = criarDocumento(db, getMockDocumento());
// Recupera um documento pelo seu ID
Document documentoRecuperado = db.getDocument(idDocumento);
// Exibe o conteúdo do documento recuperado
Log.d(TAG, "Documento: " + String.valueOf(documentoRecuperado.getProperties()));
// Atualiza o documento
atualizarDocumento(documentoRecuperado);
// Apaga o documento
apagarDocumento(documentoRecuperado);
}
Cada chamada será explicada logo abaixo.
Criando Documentos
Crie o método abaixo que será responsável pela criação de documentos:
private String criarDocumento(Database db, Map<String, Object> conteudoDocumento) {
// Cria um documento vazio
Document documento = db.createDocument();
try {
// Adiciona o conteúdo para o documento e o grava no banco de dados.
documento.putProperties(conteudoDocumento);
Log.d(TAG, "Documento gravado no banco de dados " + DATABASE_NAME + ".");
} catch (CouchbaseLiteException e) {
handleException("Não foi possível gravar o documento. Causa: ", e);
}
// Retorna o ID do documento gravado
return documento.getId();
}
Utilizamos o método createDocument() do objeto Database para criar um documento vazio.
Depois utilizamos o método putProperties(propriedades) do documento para adicionar o seu conteúdo.
Recuperando e Atualizando Documentos
Utilizaremos o método getId() documento para recuperar seu ID.
Para recuperar o documento da base basta utilizarmos o seguinte método:
Document documentoRecuperado = db.getDocument(idDocumento);
Para a atualização de documentos iremos criar o método abaixo:
private void atualizarDocumento(Document documentoRecuperado) {
Map<String, Object> propriedadesAtualizadas = new HashMap<String, Object>();
propriedadesAtualizadas.putAll(documentoRecuperado.getProperties());
propriedadesAtualizadas.put("cidadeAtual", "Belo Horizonte");
propriedadesAtualizadas.put("profissao", "Desenvolvedor");
try {
// Atualiza o documento documentoRecuperado.putProperties(propriedadesAtualizadas);
Log.d(TAG, "Atualizando documento: " + String.valueOf(documentoRecuperado.getProperties()));
} catch (CouchbaseLiteException e) {
handleException("Não foi possível atualizar o documento. Causa: ", e);
}
}
Para atualizar um documento basta apenas chamarmos o método putProperties() do documento, passando como parâmetro as propriedades atualizadas.
Apagando Documentos
private void apagarDocumento(Document documentoRecuperado) {
try {
// Apaga o documento
documentoRecuperado.delete();
Log.d(TAG, "Documento deletado, estado = " + documentoRecuperado.isDeleted());
} catch (CouchbaseLiteException e) {
handleException("Não foi possível apagar o documento. Causa: ", e);
}
}
Para apagar um documento basta apenas chamar o seu método delete(), conforme exemplo acima.
Podemos ainda verificar se o documento foi apagado com sucesso utilizando o método isDeleted(), que irá retornar true ou false.
Após alterar o projeto e realizar sua a execução, o console de logs deverá apresentar o seguinte conteúdo:
Considerações Finais
Como vimos acima a criação a manipulação de documentos utilizando o Couchbase Lite pode ser realizada de maneira simples e com apenas alguns passos, a equipe por trás de seu desenvolvimento tem uma enorme experiência com bancos de dados NoSQL, e sempre estão realizando atualizações para a sua melhoria.
Fique a vontade para expor suas dúvidas, sugestões ou até mesmo críticas.
Projeto Final
Você pode baixar o projeto completo aqui.