Building a Mobile Application with Couchbase

Parte 3: Adicionando a funcionalidade de sincronização a um servidor centralizado

Este blog com várias partes ajudará o leitor a criar um aplicativo móvel de ponta a ponta usando os recursos líderes do setor do Couchbase Lite.

Um aplicativo de última geração, de ponta a ponta, dimensionável e de nível de produção deve incluir os seguintes recursos:

- Um banco de dados incorporado para armazenar dados localmente no dispositivo e reduzir as viagens de rede para um banco de dados centralizado para cada atividade. Isso contribui muito para melhorar a experiência do usuário.
- Realizar pesquisa de texto completo no dispositivo.
- Sincronização com dispositivos móveis semelhantes e um servidor centralizado.

Esta série de posts do blog está dividida em quatro partes:

- Parte 1 apresenta o processo de criação de um aplicativo móvel que aproveita o CB Lite e o usa como um banco de dados incorporado para armazenar dados.
- Parte 2 mostra como executar o Full Text Search (FTS) no dispositivo.
- A Parte 3 apresenta a sincronização com um servidor Couchbase centralizado a partir de dispositivos de borda.
- A Parte 4 demonstrará a sincronização ponto a ponto entre dispositivos.

Estamos desenvolvendo este aplicativo com base em Servidor Couchbase e com Couchbase Mobile usados no dispositivo e para o gerenciamento de sincronização.

O Couchbase é um banco de dados em nuvem NoSQL distribuído e premiado. Ele oferece versatilidade, desempenho, escalabilidade e valor financeiro inigualáveis em implantações na nuvem, no local, híbridas, distribuídas e de computação de borda.

O Couchbase Mobile O portfólio inclui:

- Um banco de dados incorporado para dispositivos de borda.
- Um Sync Gateway de alto desempenho que oferece recursos de sincronização ponto a ponto e de servidor centralizado.
- Datacenters de borda com tecnologia do Couchbase Server que podem ser implantados na nuvem, no local ou localmente.

Adição da funcionalidade Sync

O código para este tutorial está disponível em meu sofá-base móvel Repositório do GitHub. Estamos trabalhando com o RateIt que faz parte do arquivo Rateit.zip, extraia seus arquivos para uma pasta local.

Como alternativa, você pode seguir as instruções desta série do blog para criar o aplicativo do zero.

A funcionalidade do aplicativo é dividida em três partes:

1. envio de solicitações
2. receber solicitações de outras pessoas
3. visualizar a solicitação que você enviou

Enviar solicitações de classificação

O aplicativo que criamos neste tutorial permitirá que os usuários enviem uma solicitação de classificação de tópico a uma pessoa e recebam as respostas.

A ENVIAR PARA indica o número de telefone da pessoa para quem você deseja enviar a solicitação.

O Mensagem indica o que você deseja que eles façam com ela. Nesse caso, como se trata de uma solicitação de classificação, tenho uma mensagem predefinida de: "Rate 1-5" (Classifique de 1 a 5) - indicando que eles precisam fornecer uma classificação quando enviarem a solicitação de volta.

O Assunto indica qualquer tópico sobre o qual você deseja obter uma classificação, por exemplo, pode ser apenas uma palavra ou frase como:

- Ator: Chris Hemsworth
- Livro: Orgulho e Preconceito
- www.google.com

Não há nenhuma validação rigorosa de entrada nos campos, mas isso é algo que você faria em um aplicativo móvel de nível de produção.

Quando você clica em ENVIARUma solicitação é enviada para a pessoa-alvo.

Pré-requisitos do software

Nesta parte do blog, exigimos que o software a seguir seja instalado em um desktop ou servidor que será acessado pelo seu aplicativo móvel.

Servidor Couchbase - Instale uma versão em seu laptop ou servidor local usando este link de download gratuito. Após a instalação bem-sucedida, você poderá acessar o console do Couchbase no seu navegador em http://localhost:8091.

Servidor Sync Gateway - Ele pode estar na mesma máquina de desenvolvimento que o Couchbase Server. Faça o download do Sync Gateway aqui e revisar o documentação aqui.

Siga todos os Comece aqui! etapas da documentação, destacadas aqui em verde.

Para começar, faça o seguinte:

- Inicie o Sync Gateway em seu laptop.
- Conclua todas as etapas da seção de verificação.
- Dê ao usuário acesso a todos os canais com esta instrução curl:

curl --location --request PUT 'http://127.0.0.1:4985/rateit/_user/sgwuser1' \ 
  --header 'Authorization: Basic c3luY19nYXRld2F5OnBhc3N3b3Jk' \
  --header 'Content-Type: application/json' \
  --data-raw '{ "name": "sgwuser1", "roles": ["stdrole"] ,"admin_channels": ["*"]}'

enrolar --localização --solicitação PUT 'http://127.0.0.1:4985/rateit/_user/sgwuser1' \

--cabeçalho 'Authorization: Basic c3luY19nYXRld2F5OnBhc3N3b3Jk' \

--cabeçalho 'Content-Type: application/json' \

--dados-bruto '{ "name": "sgwuser1", "roles": ["stdrole"] , "admin_channels": ["*"]}'

Apresentando o aplicativo móvel RateIt

Conforme mostrado nas postagens anteriores, a página principal do aplicativo tem três botões:

- CLIQUE PARA ENVIAR SOLICITAÇÃO DE CLASSIFICAÇÃO
- SOLICITAÇÕES DE CLASSIFICAÇÃO RECEBIDAS
- SOLICITAÇÕES DE CLASSIFICAÇÃO RECEBIDAS

Adicionaremos componentes de interface do usuário para permitir que você ative e desative a sincronização, além de fornecer uma entrada de texto para que os usuários se identifiquem.

Os arquivos de código que manipularemos são mainactivity.java e activity_main.xml.

A sincronização do dispositivo móvel com o servidor centralizado é para aplicativos que precisam atualizar constantemente um servidor centralizado com quaisquer alterações feitas nos dispositivos portáteis. Essa sincronização aplicará essas alterações a outros dispositivos se eles também compartilharem o mesmo aplicativo e a mesma conexão de banco de dados centralizado.

Revisão do código de sincronização do servidor

Adicione o seguinte código a activity_main.xml para incorporar o sincronização interruptor. É uma chave liga/desliga que permite que o usuário decida quando ativar a sincronização.

<Switch
    android:id="@+id/switch1"
    android:layout_width="158dp"
    android:layout_height="38dp"
    android:layout_marginStart="2dp"
    android:layout_marginTop="8dp"
    android:layout_marginEnd="2dp"
    android:layout_marginBottom="8dp"
    android:background="#F44336"
    android:backgroundTint="#F44336"
    android:checked="false"
    android:switchMinWidth="50dp"
    android:switchTextAppearance="@style/TextAppearance.AppCompat.Body2"
    android:text="SYNC ON/OFF"
    android:textColor="@color/black"
    android:textOff="OFF"
    android:textOn="ON"
    android:textSize="16sp"
    android:textStyle="bold"
    android:visibility="visible"
    app:layout_constraintBottom_toTopOf="@+id/send"
    app:layout_constraintEnd_toEndOf="parent"
    app:layout_constraintHorizontal_bias="0.0"
    app:layout_constraintStart_toStartOf="parent"
    app:layout_constraintTop_toBottomOf="@+id/textView" />

<Switch

androide:id="@+id/switch1"

androide:layout_width="158dp"

androide:layout_height="38dp"

androide:layout_marginStart="2dp"

androide:layout_marginTop="8dp"

androide:layout_marginEnd="2dp"

androide:layout_marginBottom="8dp"

androide:fundo="#F44336"

androide:backgroundTint="#F44336"

androide:verificado="false" (falso)

androide:switchMinWidth="50dp"

androide:switchTextAppearance="@style/TextAppearance.AppCompat.Body2"

androide:texto="SYNC ON/OFF"

androide:textColor="@color/black"

androide:textOff="OFF" (DESLIGADO)

androide:textOn="ON"

androide:textSize="16sp"

androide:textStyle="negrito"

androide:visibilidade="visível"

aplicativo:layout_constraintBottom_toTopOf="@+id/send"

aplicativo:layout_constraintEnd_toEndOf="pai"

aplicativo:layout_constraintHorizontal_bias="0.0"

aplicativo:layout_constraintStart_toStartOf="pai"

aplicativo:layout_constraintTop_toBottomOf="@+id/textView" />

O seguinte trecho de XML usa o nome de usuário como entrada do usuário e tem um rótulo associado para torná-lo fácil de usar.

<TextView
    android:id="@+id/textView5"
    android:layout_width="51dp"
    android:layout_height="35dp"
    android:layout_marginStart="16dp"
    android:layout_marginTop="8dp"
    android:background="#2196F3"
    android:gravity="center"
    android:text="USER"
    android:textStyle="bold"
    app:layout_constraintStart_toEndOf="@+id/switch1"
    app:layout_constraintTop_toBottomOf="@+id/textView" />

<EditText
    android:id="@+id/username"
    android:layout_width="154dp"
    android:layout_height="35dp"
    android:layout_marginStart="67dp"
    android:layout_marginTop="8dp"
    android:background="@color/white"
    android:backgroundTint="@color/white"
    android:ems="10"
    android:inputType="textPersonName"
    android:text="Name"
    app:layout_constraintStart_toStartOf="@+id/textView5"
    app:layout_constraintTop_toBottomOf="@+id/textView" />

<TextView

androide:id="@+id/textView5"

androide:layout_width="51dp"

androide:layout_height="35dp"

androide:layout_marginStart="16dp"

androide:layout_marginTop="8dp"

androide:fundo="#2196F3"

androide:gravidade="center" (centro)

androide:texto="USUÁRIO"

androide:textStyle="negrito"

aplicativo:layout_constraintStart_toEndOf="@+id/switch1"

aplicativo:layout_constraintTop_toBottomOf="@+id/textView" />

<EditText

androide:id="@+id/username"

androide:layout_width="154dp"

androide:layout_height="35dp"

androide:layout_marginStart="67dp"

androide:layout_marginTop="8dp"

androide:fundo="@color/white"

androide:backgroundTint="@color/white"

androide:ems="10"

androide:inputType="textPersonName"

androide:texto="Nome"

aplicativo:layout_constraintStart_toStartOf="@+id/textView5"

aplicativo:layout_constraintTop_toBottomOf="@+id/textView" />

A página inicial do aplicativo agora terá a seguinte aparência: observe os novos componentes na linha superior:

Agora vamos atualizar Mainactivity.java no Java → com.example.rateit com essas alterações:

- Adicione um código que verifique se o sincronização precisa ser alternado.
- Adicione também um código para obter a entrada do usuário campo de entrada

Switch toggleBtn = (Switch) findViewById(R.id.switch1);
EditText userid = (EditText) findViewById(R.id.username);
String username = userid.getText().toString();

Interruptor toggleBtn = (Interruptor) findViewById(R.id.interruptor1);

EditText usuário = (EditText) findViewById(R.id.nome de usuário);

Cordas nome de usuário = usuário.getText().toString();

Adicione um ouvinte para o sincronização botão de alternância que faz o seguinte:

- - Quando o botão de alternância é alterado de ON para DESLIGADO, ou vice-versa, ele ouvirá e agirá de acordo com essas alterações.
  - Quando o botão é girado DESLIGADOa replicação será interrompida.
  - Quando o botão está definido para a posição ON a replicação será iniciada.
  - Quando a replicação é ativada, instanciamos a configuração do replicador com o banco de dados local e fornecemos detalhes do banco de dados centralizado para indicar a origem e o destino das replicações push/pull.

toggleBtn.setOnCheckedChangeListener(newCompoundButton.OnCheckedChangeListener(){
@Override
        public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
            Replicator replicator = null;
            if(isChecked) {
                DatabaseConfiguration config = new DatabaseConfiguration();
                File dbFile = new File(context.getFilesDir() , "rateitdb");
                config.setDirectory(context.getFilesDir().getAbsolutePath());
                Database database = null;
                try { database = new Database("rateitdb", config); } catch (CouchbaseLiteException e) { e.printStackTrace(); }
               
                URI url = null;
                try {
                    url = new URI(String.format("%s/%s", "ws://10.0.2.2:4984", "rateit"));
                } catch (URISyntaxException e) {
                    e.printStackTrace();
                }

                Query query = null;
                CouchbaseLite.init(context);
               
                ReplicatorConfiguration replconfig = new ReplicatorConfiguration(database, new URLEndpoint(url));
                replconfig.setType(ReplicatorType.PUSH_AND_PULL);
                replconfig.setContinuous(true);
                replconfig.setAuthenticator(new BasicAuthenticator("sgwuser1", "password".toCharArray()));
                replicator = new Replicator(replconfig);
                setRepEventMonitor(replicator);
                replicator.start();
                Log.i(LogDomain.REPLICATOR.name(),"Enabled replication");
            } else {
                replicator.stop();
                Log.i(LogDomain.REPLICATOR.name(),"Disabled replication");
            }
        }
    });
    CouchbaseLite.init(context);
}

toggleBtn.setOnCheckedChangeListener(newCompoundButton.OnCheckedChangeListener(){

@Override

público vazio onCheckedChanged(CompoundButton buttonView, booleano isChecked) {

Replicador replicador = nulo;

se(isChecked) {

DatabaseConfiguration configuração = novo DatabaseConfiguration();

Arquivo dbFile = novo Arquivo(contexto.getFilesDir() , "rateitdb");

configuração.setDirectory(contexto.getFilesDir().getAbsolutePath());

Banco de dados banco de dados = nulo;

tentar { banco de dados = novo Banco de dados("rateitdb", configuração); } captura (CouchbaseLiteException e) { e.printStackTrace(); }

URI url = nulo;

tentar {

url = novo URI(Cordas.formato("%s/%s", "ws://10.0.2.2:4984", "rateit"));

} captura (URISyntaxException e) {

e.printStackTrace();

}

Consulta consulta = nulo;

CouchbaseLite.inicial(contexto);

ReplicatorConfiguration replconfig = novo ReplicatorConfiguration(banco de dados, novo URLEndpoint(url));

replconfig.setType(ReplicatorType.PUSH_AND_PULL);

replconfig.setContinuous(verdadeiro);

replconfig.setAuthenticator(novo BasicAuthenticator("sgwuser1", "senha".toCharArray()));

replicador = novo Replicador(replconfig);

setRepEventMonitor(replicador);

replicador.iniciar();

Registro.i(Domínio de registro.REPLICADOR.nome(),"Replicação ativada");

} mais {

replicador.parar();

Registro.i(Domínio de registro.REPLICADOR.nome(),"Replicação desativada");

}

});

CouchbaseLite.inicial(contexto);

}

Configure o monitor de eventos para eventos de replicação:

public void setRepEventMonitor(Replicator replicator)
{
    ListenerToken token = replicator.addDocumentReplicationListener(replication -> {
        for (ReplicatedDocument document : replication.getDocuments()) {
            Log.i(TAG, "Doc ID: " + document.getID());

            CouchbaseLiteException err = document.getError();
            if (err != null) {
                //There was an error
                Log.e(TAG, "Error replicating document: ", err);
                return;
            }
        }
    });
}

público vazio setRepEventMonitor(Replicador replicador)

{

ListenerToken token = replicador.addDocumentReplicationListener(replicação -> {

para (ReplicatedDocument documento : replicação.getDocuments()) {

Registro.i(TAG, "Doc ID: " + documento.obterID());

CouchbaseLiteException erro = documento.getError();

se (erro != nulo) {

/Houve um erro

Registro.e(TAG, "Erro ao replicar o documento: ", erro);

retorno;

}

});

}

Em Mainactivity.java também removemos muitos valores codificados dos registros de solicitações, para que possamos mostrar os registros como eles seriam para diferentes usuários.

No SENDDATA observe como os valores codificados são substituídos por campos de entrada relevantes:

MutableDocument mutableDoc = new MutableDocument();
mutableDoc.setString("type", "send");
mutableDoc.setString("sendto", String.valueOf(sendto));
mutableDoc.setString("from", username);
mutableDoc.setString("to", sendto);
mutableDoc.setString("URL", String.valueOf(URLlink));
mutableDoc.setString("rating", String.valueOf(rating));
mutableDoc.setDate("createdAt", new Date());

MutableDocument mutableDoc = novo MutableDocument();

mutableDoc.setString("tipo", "enviar");

mutableDoc.setString("sendto", Cordas.valueOf(enviar para));

mutableDoc.setString("de", nome de usuário);

mutableDoc.setString("para", enviar para);

mutableDoc.setString("URL", Cordas.valueOf(Link de URL));

mutableDoc.setString("classificação", Cordas.valueOf(classificação));

mutableDoc.setDate("createdAt", novo Data());

No DADOS RECEBIDOS removemos a gravação extra que anteriormente emulava a obtenção de uma solicitação de classificação. Isso está obsoleto agora que adicionamos a função USUÁRIO campo de entrada que nos permite obter a classificação/solicitações de volta para o usuário específico.

SearchView search = (SearchView) findViewById(R.id.searchView);
Expression searchExp = FullTextExpression.index("descFTSIndex").match(String.valueOf(search.getQuery())) ;
Query query = null;
if (search.getQuery().toString().trim().isEmpty()) {
    query = (Query) QueryBuilder.select(SelectResult.all()).from(DataSource.database(database))
            .where(Expression.property("to").equalTo(Expression.string(username))
                    .and(Expression.property("type").equalTo(Expression.string("send"))));

} else {
    query = (Query) QueryBuilder.select(SelectResult.all()).from(DataSource.database(database))
            .where(Expression.property("to").equalTo(Expression.string(username))
                    .and(Expression.property("type").equalTo(Expression.string("send")))
                    .and(searchExp));
}

int numrows = query.execute().allResults().size();
Toast.makeText(getApplicationContext(), "num rows:::"+ numrows , Toast.LENGTH_LONG).show();

try {
    query.execute().allResults().forEach(result -> {
        Dictionary thisDocsProps = result.getDictionary(0);
        String from = thisDocsProps.getString("from").trim();
        String to = thisDocsProps.getString("to").trim();
        String sendto = thisDocsProps.getString("sendto").trim();
        String URL = thisDocsProps.getString("URL").trim();
        String rating = thisDocsProps.getString("rating").trim();
        float ratingstars = thisDocsProps.getFloat("ratingstars");
        int stars = (int) ratingstars;
        rating = String.valueOf(thisDocsProps.getFloat("ratingstars"));

        userArray.add(new User(username,from, sendto, URL, rating,ratingstars));
    });
} catch (CouchbaseLiteException e) {
    e.printStackTrace();
}

SearchView pesquisa = (SearchView) findViewById(R.id.searchView);

Expressão searchExp = FullTextExpression.índice("descFTSIndex").partida(Cordas.valueOf(pesquisa.getQuery())) ;

Consulta consulta = nulo;

se (pesquisa.getQuery().toString().acabamento().isEmpty()) {

consulta = (Consulta) Criador de consultas.selecionar(SelecionarResultado.todos()).de(Fonte de dados.banco de dados(banco de dados))

.onde(Expressão.propriedade("para").igual a(Expressão.string(nome de usuário))

.e(Expressão.propriedade("tipo").igual a(Expressão.string("enviar"))));

} mais {

consulta = (Consulta) Criador de consultas.selecionar(SelecionarResultado.todos()).de(Fonte de dados.banco de dados(banco de dados))

.onde(Expressão.propriedade("para").igual a(Expressão.string(nome de usuário))

.e(Expressão.propriedade("tipo").igual a(Expressão.string("enviar")))

.e(searchExp));

}

int linhas numéricas = consulta.executar().allResults().tamanho();

Torradas.makeText(getApplicationContext(), "num rows:::"+ linhas numéricas , Torradas.LENGTH_LONG).show();

tentar {

consulta.executar().allResults().forEach(resultado -> {

Dicionário thisDocsProps = resultado.getDictionary(0);

Cordas de = thisDocsProps.getString("de").acabamento();

Cordas para = thisDocsProps.getString("para").acabamento();

Cordas enviar para = thisDocsProps.getString("sendto").acabamento();

Cordas URL = thisDocsProps.getString("URL").acabamento();

Cordas classificação = thisDocsProps.getString("classificação").acabamento();

flutuante estrelas de classificação = thisDocsProps.getFloat("ratingstars");

int estrelas = (int) estrelas de classificação;

classificação = Cordas.valueOf(thisDocsProps.getFloat("ratingstars"));

userArray.adicionar(novo Usuário(nome de usuário,de, enviar para, URL, classificação,estrelas de classificação));

});

} captura (CouchbaseLiteException e) {

e.printStackTrace();

}

No INCOMINGRATINGS reduza o código para obter solicitações com base em nome de usuário:

Query query = (Query) QueryBuilder.select(SelectResult.all()).from(DataSource.database(database))
        .where(Expression.property("from").equalTo(Expression.string(username))
                .and(Expression.property("type").equalTo(Expression.string("rated"))));
int numrows = query.execute().allResults().size();
Toast.makeText(getApplicationContext(), "num rows:::"+ numrows , Toast.LENGTH_LONG).show();

try {
    query.execute().allResults().forEach(result -> {
        Dictionary thisDocsProps = result.getDictionary(0);
        String sendto = thisDocsProps.getString("sendto").trim();
        String URL = thisDocsProps.getString("URL").trim();
        String rating = thisDocsProps.getString("rating").trim();
        float ratingstars = thisDocsProps.getFloat("ratingstars");
        int stars = (int) ratingstars;
        rating = String.valueOf(thisDocsProps.getFloat("ratingstars"));
        RatedArray.add(new Rated(sendto, URL, rating));
    });
} catch (CouchbaseLiteException e) {
    e.printStackTrace();
}

Consulta consulta = (Consulta) Criador de consultas.selecionar(SelecionarResultado.todos()).de(Fonte de dados.banco de dados(banco de dados))

.onde(Expressão.propriedade("de").igual a(Expressão.string(nome de usuário))

.e(Expressão.propriedade("tipo").igual a(Expressão.string("classificado"))));

int linhas numéricas = consulta.executar().allResults().tamanho();

Torradas.makeText(getApplicationContext(), "num rows:::"+ linhas numéricas , Torradas.LENGTH_LONG).show();

tentar {

consulta.executar().allResults().forEach(resultado -> {

Dicionário thisDocsProps = resultado.getDictionary(0);

Cordas enviar para = thisDocsProps.getString("sendto").acabamento();

Cordas URL = thisDocsProps.getString("URL").acabamento();

Cordas classificação = thisDocsProps.getString("classificação").acabamento();

flutuante estrelas de classificação = thisDocsProps.getFloat("ratingstars");

int estrelas = (int) estrelas de classificação;

classificação = Cordas.valueOf(thisDocsProps.getFloat("ratingstars"));

RatedArray.adicionar(novo Classificado(enviar para, URL, classificação));

});

} captura (CouchbaseLiteException e) {

e.printStackTrace();

}

Algumas atualizações foram feitas no UserCustomAdapter.java e RatedCustomerAdapter.java também. Para essa iteração, removeremos muitos arquivos DE e PARA porque queremos mostrar o aplicativo para dois usuários diferentes. Isso ajuda a mostrar como funciona a sincronização bidirecional entre o aplicativo e o servidor.

Mudanças semelhantes foram feitas para remover nomes codificados e levamos adiante o nome de usuário e solicitação detalhes na página principal do aplicativo.

Compilação do código do aplicativo móvel

Quando todo o código tiver sido atualizado, clique em Build → ReBuild Project, então Criar → Executar quando a reconstrução estiver concluída.

Você será solicitado a escolher o emulador na primeira vez que executar o aplicativo. Criei o dispositivo NEXUS 5X API 25 e o escolhi quando solicitado.

Quando a execução for concluída, a página principal terá a seguinte aparência:

Agora você implantou com êxito o código no emulador de sua escolha.

Um teste rápido

Vamos criar uma solicitação de classificação seguindo estas etapas:

Gire o SINCRONIZAÇÃO ligar.
Insira os detalhes da solicitação de classificação (usuário-alvo, mensagem, assunto).
Clique em CLIQUE PARA ENVIAR SOLICITAÇÃO DE CLASSIFICAÇÃO.
Acesse a instância do Couchbase Server. No meu caso, é o console da Web da minha instância local. Navegue até Baldes e Documentos e você verá a solicitação de classificação criada no servidor.
Agora insira o nome de usuário AlPacino e clique em SOLICITAÇÕES DE CLASSIFICAÇÃO RECEBIDAS-Você deverá ver a solicitação de classificação na seção RECEBIDO seção pronta para ser avaliada. Avalie esta solicitação.
Ao verificar o console, você verá dois documentos JSON, conforme mostrado abaixo.

Observe os dois registros no console.

Agora, vamos fazer uma alteração na solicitação classificada por AlPacino e altere o número de estrelas para 2 e ver se as alterações chegam ao dispositivo.

Execute o aplicativo e abra SOLICITAÇÕES CLASSIFICADAS RECEBIDAS (parte inferior da tela) para TomCruise e você verá a alteração para 2 estrelas.

Próximas etapas

Esta é a parte 3 da série do blog Criando um aplicativo móvel com o Couchbase. Esta postagem mostrou como ativar a sincronização entre dispositivos e servidores.

Na próxima parte da série, mostraremos como ativar a sincronização de dispositivos ponto a ponto.

Continue aprendendo seguindo esses recursos:

Sandhya Krishnamurthy, engenheira de soluções sênior, Couchbase

Platform

Self-Managed

Services

Capabilities

Why Couchbase?

Migrate to Capella

By Use Case

By Industry

By Application Need

Popular Docs

By Developer Role

Quickstart

Resource Center

About

Partnerships

Our Services

Partners: Register a Deal

Ready to register a deal with Couchbase?

Marriott

Todas as publicações

Criação de um aplicativo móvel com o Couchbase - Parte 3

Parte 3: Adicionando a funcionalidade de sincronização a um servidor centralizado

Adição da funcionalidade Sync

Enviar solicitações de classificação

Pré-requisitos do software

Apresentando o aplicativo móvel RateIt

Revisão do código de sincronização do servidor

Compilação do código do aplicativo móvel

Um teste rápido

Próximas etapas

Autor

Postado por Sandhya Krishnamurthy, engenheira de soluções sênior, Couchbase

Deixar uma resposta Cancelar resposta