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 tdcollatorso.zip.
4 - Extraia o arquivo tdcollatorso.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.

Fonte

Couchbase Training