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.

Informações do Projeto Android

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:

Android Manifest

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:

Arquivos Extraídos

5 - Após a adição de todas as bibliotecas, sua pasta libs deverá estar parecida com a seguinte:

Libraries

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:

Tela Inicial

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:

Tela de log inicial da aplicação

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:

Log Final

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.

Fonte

Couchbase Training