Ship an update to your Android app with Couchbase Mobile

Com novas ferramentas, como o Android Public Beta Testing e o Testflight para iOS, o envio de novas atualizações de um aplicativo móvel nativo com mais regularidade é uma tendência crescente.

Além de alterar a lógica comercial e os modelos de dados com mais regularidade, também é necessário oferecer suporte a versões anteriores. Ao contrário de um site em que o usuário sempre acessa a versão mais recente no navegador, os aplicativos móveis podem permanecer no dispositivo do usuário por um longo período de tempo sem serem atualizados.

Neste tutorial, você aprenderá a enviar uma atualização para seu aplicativo Android com o Couchbase Mobile. Você usará um webhook do Sync Gateway para importar dados de uma API de terceiros sob demanda (neste caso, a API do Google Places) com o Node.js. Na primeira instância, o aplicativo Android sincronizará todos os dados e, em uma versão subsequente do aplicativo, extrairá apenas um subconjunto deles. Ao alterar as regras de acesso na função Sync, você usará o Sync Gateway ressincronização para reconstruir as regras de acesso de acordo com a Sync Function atualizada.

Vamos começar!

A ordem em que você montará os diferentes componentes é a seguinte:

Instalação do Sync Gateway
Configuração do webhook
Criação do servidor de aplicativos
Criação do aplicativo Android

Primeiros passos

Faça o download do Sync Gateway e descompacte o arquivo:

http://www.couchbase.com/nosql-databases/downloads#Couchbase_Mobile

Você pode encontrar o binário do Sync Gateway no diretório caixa e exemplos de arquivos de configuração na pasta exemplos pasta. Copie o basic-walrus-bucket.json na raiz do seu projeto:

$ cp /Downloads/couchbase-sync-gateway/examples/basic-walrus-bucket.json /path/to/proj/sync-gateway-config.json

1	$ cp /Downloads/couchbase-sincronização-portal/exemplos/básico-morsa-balde.json /caminho/para/projeto/sincronização-portal-configuração.json

Inicie o Sync Gateway:

$ ~/Downloads/couchbase-sync-gateway/bin/sync_gateway

1	$ ~/Downloads/couchbase-sincronização-portal/caixa/portais de sincronização

Webhook do gateway de sincronização

O webhook é definido no arquivo de configuração que você criou acima e recebe um url para o POST e um função de filtro (opcional). Adicione o manipuladores de eventos campo em sync-gateway-config.json com as seguintes propriedades:

{
  "log": ["*"],
  "databases": {
    "db": {
      "bucket": "default",
      "server": "http://localhost:8091",
      "users": { "GUEST": { "disabled": false, "admin_channels": ["*"] } },
      "event_handlers": {
        "document_changed": [
          {
            "handler": "webhook",
            "url": "http://localhost:8000/sync_request",
            "filter": `function(doc) {
              if (doc.type == "profile") {
                return true;
              }
              return false;
            }`
          }
        ]
      }
    }
  }
}

{

"log": ["*"],

"bancos de dados": {

"db": {

"bucket" (balde): "default",

"servidor": "http://localhost:8091",

"usuários": { "CONVIDADO": { "desativado": falso, "admin_channels": ["*"] } },

"event_handlers": {

"document_changed": [

{

"handler": "webhook",

"url": "http://localhost:8000/sync_request",

"filtro": `função(doc) {

se (doc.tipo == "profile" (perfil)) {

retorno verdadeiro;

}

retorno falso;

}

]

}

Veja a seguir o que cada novo campo está fazendo:

manipulador: Você está especificando o tipo de evento a ser webhook
url: O URL para o qual enviar a solicitação POST com o documento no corpo da mensagem
filtro: Uma função escrita em JavaScript para acionar o webhook somente se ele retornar verdadeiro. Observe aqui que o webhook será executado somente se o documento tiver um tipo propriedade igual a perfil

Salve as alterações e reinicie o Sync Gateway:

$ ~/Downloads/couchbase-sync-gateway/bin/sync_gateway ./sync-gateway-config.json

1	$ ~/Downloads/couchbase-sincronização-portal/caixa/sincronização_portal ./sincronização-portal-configuração.json

Servidor de aplicativos

Nesta seção, você usará o Node.js e a estrutura Express para configurar um App Server para lidar com o webhook. No mesmo diretório, instale os módulos Node.js necessários:

npm install express body-parser --save

1	npm instalar expresso corpo-analisador --salvar

Em um novo arquivo chamado servidor.js adicione o seguinte código:

var express = require('express');
var bodyParser = require('body-parser');
var app = express();
app.use(bodyParser.json());

/**
 * Handle the Sync Gateway webhook request.
 * The request body contains the document.
 */
app.post('/sync_request', function (req, res) {
  var document = req.body;
  console.log('Handle webhook with doc :: %s', JSON.stringify(document));
  res.sendStatus(200);
});

var server = app.listen(8000, function () {
  var host = server.address().address;
  var port = server.address().port;

  console.log('App listening at http://%s:%s', host, port);
});

var expresso = exigir("expresso);

var bodyParser = exigir('body-parser');

var aplicativo = expresso();

aplicativo.uso(bodyParser.json());

/**

* Tratar a solicitação do webhook do Sync Gateway.

* O corpo da solicitação contém o documento.

aplicativo.postagem('/sync_request', função (req, res) {

var documento = req.corpo;

console.registro('Manipular webhook com documento :: %s', JSON.stringify(documento));

res.sendStatus(200);

});

var servidor = aplicativo.ouvir(8000, função () {

var hospedeiro = servidor.endereço().endereço;

var porto = servidor.endereço().porto;

console.registro('App listening em http://%s:%s', hospedeiro, porto);

});

Inicie o servidor de aplicativos Node.js executando servidor de nó.js e salve um documento no Sync Gateway usando a API REST para garantir que o webhook esteja funcionando:

$ curl -vX POST :4984/db/ 
        -H 'Content-Type: application/json' 
        -d '{"type": "profile", "name": "james"}'

$ enrolar -vX POST :4984/db/

-H 'Content-Type: application/json'

-d '{"type": "profile", "name": "james"}'

Você deverá ver a seguinte saída nos logs do App Server:

Excelente! O webhook está funcionando. Em seguida, você adicionará algum código para importar os dados JSON da API Places para o Sync Gateway. Para isso, você usará o RxJS e o Request. O código que lida com mais de um evento ou computação assíncrona se complica rapidamente. O RxJS faz esses cálculos cidadãos de primeira classe e fornece um modelo que permite APIs legíveis e compostas. E o módulo Request é a biblioteca de fato para tornar as solicitações http no NodeJS mais simples do que nunca. No mesmo diretório, vá em frente e instale as dependências:

$ npm install request rx --save

1	$ npm instalar solicitação rx --salvar

Cópia requestRx.js a partir deste Repositório do GitHub na pasta do seu projeto. Estamos simplesmente envolvendo a API de solicitação em construções RxJS (flatMap, filter, subscribe...). Por exemplo, em vez de usar request.getvocê usará requestRx.get.

Abra um novo arquivo chamado sync.js, exigem que o requestRx e Rx e adicione o seguinte código:

var requestRx = require('./requestRx.js');
var Rx = require('rx');

const api_key = 'AIzaSyD4e6ZUIc9G2AxKansIUKa0enFzWZy5h8w';
const url = 'https://maps.googleapis.com/maps/api/place';
const gateway = 'http://localhost:4985/db';

var SyncRequest = {
  syncRequest: function(city) {
    console.log('city to sync with %s', city);
    // 1. Search for Places
    requestRx.get(`${url}/textsearch/json?key=${api_key}&amp;query=restaurants+in+${city}`)
      .subscribe((res) =&gt; {
        var places = JSON.parse(res.body).results;
        places = places.map(function (place) {
          place.city = city;
          place._id = place.place_id;
          delete place.place_id;
          return place;
        });
        var placesStream = Rx.Observable.fromArray(places);

        // 2. Send the Places in bulk to Sync Gateway
        requestRx({uri: `${gateway}/_bulk_docs`, method: 'POST', json: {docs: places}})
          .flatMap((docsRes) =&gt; {
            var docsStream = Rx.Observable.fromArray(docsRes.body);

            // Merge the place's photoreference with the doc id and rev
            return Rx.Observable.zip(placesStream, docsStream, (place, doc) =&gt; {
              return {
                id: doc.id,
                rev: doc.rev,
                ref: place.photos ? place.photos[0].photo_reference : 'CmRdAAAAA6MaWi5PIUhFumEYbHiM8IWHhJJvw1ss11QH1prE_x0PnUgyiyIiQmSNvfMu1lztLAA0mNdZa5Mr32ho5hE5nOKDAdOfVKcw4kLe0LKdDoYFENmRR1FE4AosTUhBvNCvEhB5HYf69MG389U27lkhrcPqGhSDbG7UhU9buWSEn2DRpy8E_R3oAg'
              }
            });
          })
          .flatMap((doc) =&gt; {

            // 3. Get the binary jpg photo using the ref property (i.e. photoreference)
            var options = {
              uri: `${url}/photo?key=${api_key}&amp;maxwidth=400&amp;photoreference=${doc.ref}`,
              encoding: null
            };
            return requestRx.get(options)
              .flatMap((photo) =&gt; {

                // 4. Save the photo as an attachment on the corresponding document
                return requestRx({
                  uri: `${gateway}/${doc.id}/photo?rev=${doc.rev}`,
                  method: 'PUT',
                  headers: {'Content-Type': 'image/jpg'},
                  body: photo.body
                })
              })
          })
          .subscribe((res) =&gt; {
          });
      });
  }
};

module.exports = SyncRequest;

var requestRx = exigir('./requestRx.js');

var Rx = exigir('rx');

const chave api = 'AIzaSyD4e6ZUIc9G2AxKansIUKa0enFzWZy5h8w';

const url = 'https://maps.googleapis.com/maps/api/place';

const portal = 'http://localhost:4985/db';

var SyncRequest = {

syncRequest: função(cidade) {

console.registro('cidade para sincronizar com o %s', cidade);

// 1. pesquisar locais

requestRx.obter(`${url}/pesquisa de texto/json?chave=${chave api}&amplificador;consulta=restaurantes+em+${cidade}`)

.assinar((res) => {

var lugares = JSON.analisar(res.corpo).resultados;

lugares = lugares.mapa(função (lugar) {

lugar.cidade = cidade;

lugar._id = lugar.place_id;

excluir lugar.place_id;

retorno lugar;

});

var placesStream = Rx.Observável.fromArray(lugares);

// Enviar os locais em massa para o Sync Gateway

requestRx({uri: `${portal}/_bulk_docs`, método: 'POST', json: {documentos: lugares}})

.flatMap((docsRes) => {

var docsStream = Rx.Observável.fromArray(docsRes.corpo);

// Mesclar a fotorreferência do local com o ID e a revisão do documento

retorno Rx.Observável.zíper(placesStream, docsStream, (lugar, doc) => {

retorno {

id: doc.id,

rev: doc.rev,

ref: lugar.fotos ? lugar.fotos[0].foto_referência : 'CmRdAAAAA6MaWi5PIUhFumEYbHiM8IWHhJJvw1ss11QH1prE_x0PnUgyiyIiQmSNvfMu1lztLAA0mNdZa5Mr32ho5hE5nOKDAdOfVKcw4kLe0LKdDoYFENmRR1FE4AosTUhBvNCvEhB5HYf69MG389U27lkhrcPqGhSDbG7UhU9buWSEn2DRpy8E_R3oAg'

}

});

})

.flatMap((doc) => {

// Obtenha a foto jpg binária usando a propriedade ref (ou seja, fotoreferência)

var opções = {

uri: `${url}/foto?chave=${chave api}&amplificador;largura máxima=400&amplificador;fotorreferência=${doc.ref}`,

codificação: nulo

};

retorno requestRx.obter(opções)

.flatMap((foto) => {

// Salve a foto como um anexo no documento correspondente

retorno requestRx({

uri: `${portal}/${doc.id}/foto?rev=${doc.rev}`,

método: 'PUT',

cabeçalhos: {'Content-Type': 'image/jpg'},

corpo: foto.corpo

})

.assinar((res) => {

});

}

};

módulo.exportações = SyncRequest;

Veja a seguir o que está acontecendo passo a passo:

Obter os Locais que correspondem à consulta restaurantes em Londres. Use o recurso de interpolação de strings do ES 6 na url.
O volumedocumentos é muito conveniente para a importação de grandes conjuntos de dados para uma instância do Sync Gateway. Leia mais sobre ele na seção documentos.
Depois de salvar o documento e salvar a foto como anexo, você deve primeiro obter a imagem da API do Places. Observe a codificação é definida como nulo. Isso é exigido pelo módulo Request para qualquer corpo de resposta que não seja uma string. Leia mais sobre isso na seção Solicitar documentos.
Você deve informar ao Sync Gateway em qual documento (especificando o ID do documento) e a revisão desse documento (especificando o número da revisão) salvar esse anexo.

Observe que na última linha você está exportando o SyncRequest objeto. Em servidor.js, exigem que o sync.js e chamar o arquivo syncRequest passando o método cidade campo:

var express = require('express');
var bodyParser = require('body-parser');
var app = express();
app.use(bodyParser.json());

var sync = require('./sync');

/**
 * Handle the Sync Gateway webhook request.
 * The request body contains the document.
 */
app.post('/sync_request', function (req, res) {
  var document = req.body;
  console.log('Handle webhook with doc :: %s', JSON.stringify(document));
  sync.syncRequest(document.city);
  res.sendStatus(200);
});

var server = app.listen(8000, function () {
  var host = server.address().address;
  var port = server.address().port;

  console.log('App listening at http://%s:%s', host, port);
});

var expresso = exigir("expresso);

var bodyParser = exigir('body-parser');

var aplicativo = expresso();

aplicativo.uso(bodyParser.json());

var sincronização = exigir('./sync');

/**

* Tratar a solicitação do webhook do Sync Gateway.

* O corpo da solicitação contém o documento.

aplicativo.postagem('/sync_request', função (req, res) {

var documento = req.corpo;

console.registro('Manipular webhook com documento :: %s', JSON.stringify(documento));

sincronização.syncRequest(documento.cidade);

res.sendStatus(200);

});

var servidor = aplicativo.ouvir(8000, função () {

var hospedeiro = servidor.endereço().endereço;

var porto = servidor.endereço().porto;

console.registro('App listening em http://%s:%s', hospedeiro, porto);

});

Você deve ter notado que sync.js é escrito com a sintaxe ES6. Em execução servidor de nó.js não funcionará e você deve primeiro instalar o Babel módulo globalmente:

npm install babel-node -g

1	npm instalar babel-nó -g

Agora você pode executar o sync.js de forma independente com o seguinte comando:

babel-node -e "require('./sync.js').syncRequest('London')"

1	babel-nó -e "require('./sync.js').syncRequest('London')"

Abra o Admin Dashboard para monitorar os documentos que foram salvos no Sync Gateway.

http://localhost:4985/_admin/

Agora você deve ver 20 documentos, sendo que cada um deles é um local em Londres:

Criação do aplicativo Android

Nesta seção, você aprenderá a usar o SDK do Google Maps no Android para obter a cidade em que o usuário está localizado no momento. Com essas informações, você criará um documento do tipo perfil para armazenar a cidade atual.

Abra o Android Studio e selecione Iniciar um novo projeto do Android Studio do Início rápido menu.

Nomear o aplicativo CityExplorerdefina um domínio da empresa e um local do projeto adequados e clique em Próximo:

Na caixa de diálogo Target Android Devices (Dispositivos Android de destino), certifique-se de marcar Telefone e tabletdefina o SDK mínimo como API 22: Android 5.1 (Lollipop) para ambos, e clique em Próximo:

No dia seguinte Adicionar uma atividade ao Mobile selecione Add Atividade em branco e nomeie a atividade Atividade principal:

Você usará o provedor de localização fundido para recuperar a última localização conhecida do dispositivo. Em build.gradleadicione a seguinte dependência:

compile 'com.google.android.gms:play-services:7.5.0'

1	compilar 'com.google.android.gms:play-services:7.5.0'

Adicionar uma permissão de solicitação de localização em AndroidManifest.xml no manifesto Etiqueta XML:

Em MainActivity.javaadicione um novo método chamado criar cliente GoogleApi para inicializar o SDK da API do Google e chamar o método em onCreate:

protected synchronized void buildGoogleApiClient() {
    mGoogleApiClient = new GoogleApiClient.Builder(this)
            .addConnectionCallbacks(this)
            .addOnConnectionFailedListener(this)
            .addApi(LocationServices.API)
            .build();
    mGoogleApiClient.connect();
}

protegida sincronizado vazio criar cliente GoogleApi() {

mGoogleApiClient = novo Cliente GoogleApi.Construtor(este)

.addConnectionCallbacks(este)

.addOnConnectionFailedListener(este)

.addApi(Serviços de localização.API)

.construir();

mGoogleApiClient.conectar();

}

Em seguida, você fará Atividade principal implementar o GoogleApiClient.ConnectionCallbacks e GoogleApiClient.OnConnectionFailedListener e recuperar o local em onConnected:

@Override
public void onConnected(Bundle bundle) {
    Location mLastLocation = LocationServices.FusedLocationApi.getLastLocation(mGoogleApiClient);
    Geocoder geocoder = new Geocoder(this, Locale.getDefault());
    List

@Substituir

público vazio onConnected(Pacote feixe) {

Localização mLastLocation = Serviços de localização.FusedLocationApi.getLastLocation(mGoogleApiClient);

Geocodificador geocodificador = novo Geocodificador(este, Local.getDefault());

Lista

addresses = null; try { addresses = geocoder.getFromLocation(mLastLocation.getLatitude(), mLastLocation.getLongitude(), 1); } catch (IOException e) { e.printStackTrace(); } if (addresses.size() > 0) { String city = addresses.get(0).getLocality(); cityLabel.setText(city); } } @Override public void onConnectionSuspended(int i) { } @Override public void onConnectionFailed(ConnectionResult connectionResult) { }

Execute o aplicativo e você verá a cidade atual exibida no meio da tela:

Em seguida, você adicionará o Couchbase Lite ao seu projeto. Em build.gradle adicione o seguinte:

// workaround for "duplicate files during packaging of APK" issue
// see https://groups.google.com/d/msg/adt-dev/bl5Rc4Szpzg/wC8cylTWuIEJ
packagingOptions {
    exclude 'META-INF/ASL2.0'
    exclude 'META-INF/LICENSE'
    exclude 'META-INF/NOTICE'
}

// solução alternativa para o problema de "arquivos duplicados durante o empacotamento do APK

// consulte https://groups.google.com/d/msg/adt-dev/bl5Rc4Szpzg/wC8cylTWuIEJ

packagingOptions {

excluir 'META-INF/ASL2.0'

excluir 'META-INF/LICENSE'

excluir 'META-INF/NOTICE'

}

Adicione o pacote do Couchbase Lite para Android em build.gradle:

compile 'com.couchbase.lite:couchbase-lite-android:1.1.0'

1	compilar 'com.couchbase.lite:couchbase-lite-android:1.1.0'

Criar um SyncManager.java e adicione o código para iniciar uma replicação pull e push no modo contínuo:

public class SyncManager {
    private static final String DATABASE_NAME = "cityexplorer";
    private static final String SYNC_URL = "http://localhost:4984/db/";
    private static final String CITIES_VIEW = "getCities";

    private Context context;
    private Manager manager;
    private Database database;

    public SyncManager(Context context) {
        this.context = context;

        openDatabase();
    }

    private void openDatabase() {
        try {
            manager = new Manager(new AndroidContext(context), Manager.DEFAULT_OPTIONS);
        } catch (IOException e) {
            e.printStackTrace();
        }

        try {
            database = manager.getDatabase(DATABASE_NAME);
        } catch (CouchbaseLiteException e) {
            e.printStackTrace();
        }

        startSync();
    }

    private void startSync() {
        URL url = null;
        try {
            url = new URL(SYNC_URL);
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }

        Replication push = database.createPushReplication(url);
        push.setContinuous(true);
        push.start();

        Replication pull = database.createPullReplication(url);
        pull.setContinuous(true);
        pull.start();
    }

    public Database getDatabase() {
        return database;
    }

    public void setDatabase(Database database) {
        this.database = database;
    }
}

público classe Gerenciador de sincronização {

privado estático final Cordas NOME DO BANCO DE DADOS = "cityexplorer";

privado estático final Cordas SYNC_URL = "http://localhost:4984/db/";

privado estático final Cordas VISÃO DAS CIDADES = "getCities";

privado Contexto contexto;

privado Gerente gerente;

privado Banco de dados banco de dados;

público Gerenciador de sincronização(Contexto contexto) {

este.contexto = contexto;

openDatabase();

}

privado vazio openDatabase() {

tentar {

gerente = novo Gerente(novo AndroidContext(contexto), Gerente.DEFAULT_OPTIONS);

} captura (IOException e) {

e.printStackTrace();

}

tentar {

banco de dados = gerente.getDatabase(NOME DO BANCO DE DADOS);

} captura (CouchbaseLiteException e) {

e.printStackTrace();

}

startSync();

}

privado vazio startSync() {

URL url = nulo;

tentar {

url = novo URL(SYNC_URL);

} captura (ExceçãoURLE malformada e) {

e.printStackTrace();

}

Replicação empurrar = banco de dados.createPushReplication(url);

empurrar.setContinuous(verdadeiro);

empurrar.iniciar();

Replicação puxar = banco de dados.createPullReplication(url);

puxar.setContinuous(verdadeiro);

puxar.iniciar();

}

público Banco de dados getDatabase() {

retorno banco de dados;

}

público vazio setDatabase(Banco de dados banco de dados) {

este.banco de dados = banco de dados;

}

Execute o aplicativo e dê uma olhada no LogCat, e você verá que a replicação foi bem-sucedida. Mas não há como consultar os documentos que foram sincronizados até o momento. Para fazer isso, você usará um Couchbase View que indexará os documentos por seus cidade propriedade.

Em SyncManager.javaadicione o seguinte método:

private void registerViews() {
    View citiesView = database.getView(CITIES_VIEW);
    citiesView.setMapReduce(new Mapper() {
        @Override
        public void map(Map&lt;String, Object&gt; document, Emitter emitter) {
            if (document.get("name") != null) {
                List<object width="300" height="150"> key = new ArrayList<object>();
                key.add(document.get("city"));
                emitter.emit(key, null);
            }
        }
    }, new Reducer() {
        @Override
        public Object reduce(List<object> keys, List<object> values, boolean rereduce) {
            return new Integer(values.size());
        }
    }, "7");
}

To query that view, add another method called <strong>queryCities</strong> like so:
<pre>
private void queryCities() {
    Query query = database.getView(CITIES_VIEW).createQuery();
    query.setGroupLevel(1);
    try {
        QueryEnumerator enumeration = query.run();
        for (QueryRow row : enumeration) {
            System.out.println("Row is " + row.getValue() + " and key " + row.getKey());
        }
    } catch (CouchbaseLiteException e) {
        e.printStackTrace();
    }
}

privado vazio registrar visualizações() {

Ver cidadesVer = banco de dados.getView(VISÃO DAS CIDADES);

cidadesVer.setMapReduce(novo Mapeador() {

@Substituir

público vazio mapa(Mapa<Cordas, Objeto> documento, Emissor emissor) {

se (documento.obter("name" (nome)) != nulo) {

Lista<objeto largura="300" altura="150"> chave = novo ArrayList<objeto>();

chave.adicionar(documento.obter("cidade"));

emissor.emitir(chave, nulo);

}

}, novo Redutor() {

@Substituir

público Objeto reduzir(Lista<objeto> chaves, Lista<objeto> valores, booleano Reduzir) {

retorno novo Inteiro(valores.tamanho());

}

}, "7");

}

Para consulta que visualização, adicionar outro método chamado <forte>consultarCidades</forte> como assim:

<pré>

privado vazio consultarCidades() {

Consulta consulta = banco de dados.getView(VISÃO DAS CIDADES).createQuery();

consulta.setGroupLevel(1);

tentar {

QueryEnumerator enumeração = consulta.executar();

para (QueryRow fila : enumeração) {

Sistema.fora.println("Row is " + fila.getValue() + " e a chave " + fila.getKey());

}

} captura (CouchbaseLiteException e) {

e.printStackTrace();

}

E o chamem depois registrar visualizações no openDatabase Execute o aplicativo e você verá o número de locais em cada cidade no LogCat:Você também configurou a replicação por push, mas ainda não persistiu nenhum documento localmente. Na seção onConnected método de MainActivity.java você adicionará código para manter um novo documento localmente com um tipo propriedade igual a perfil e cidade Antes de executar o aplicativo, vamos recapitular os diferentes componentes dessa arquitetura:Observe que as setas estão agrupadas por cor:

Laranja: Quando um usuário abre o aplicativo, o documento de perfil é mantido localmente e enviado ao Sync Gateway por meio da replicação contínua por push e aciona um webhook.
Azul: O App Server lida com os webhooks e importa os locais de uma determinada cidade para o Sync Gateway.
Verde: O usuário apropriado recebe os documentos de acordo com as regras de acesso definidas na Função de sincronização.

O Verde sempre ocorrerá algum tempo depois que o aplicativo for aberto. Seria bom monitorar a consulta de cidades no aplicativo Android para monitorar os dados à medida que eles são extraídos do Sync Gateway. Você fará isso usando um LiveQuery no lugar de um Consulta. Atualizar o consultarCidades para o seguinte:

private void queryCities() {
    final Query query = database.getView(CITIES_VIEW).createQuery();
    query.setGroupLevel(1);
    LiveQuery liveQuery = query.toLiveQuery();
    liveQuery.addChangeListener(new LiveQuery.ChangeListener() {
        @Override
        public void changed(LiveQuery.ChangeEvent event) {
            try {
                QueryEnumerator enumeration = query.run();
                for (QueryRow row : enumeration) {
                    Log.d("CityExplorer", "Row is " + row.getValue() + " and key " + row.getKey());
                }
            } catch (CouchbaseLiteException e) {
                e.printStackTrace();
            }
        }
    });
    liveQuery.start();
}

privado vazio consultarCidades() {

final Consulta consulta = banco de dados.getView(VISÃO DAS CIDADES).createQuery();

consulta.setGroupLevel(1);

LiveQuery Consulta ao vivo = consulta.toLiveQuery();

Consulta ao vivo.addChangeListener(novo LiveQuery.ChangeListener() {

@Substituir

público vazio alterado(LiveQuery.ChangeEvent evento) {

tentar {

QueryEnumerator enumeração = consulta.executar();

para (QueryRow fila : enumeração) {

Registro.d("CityExplorer", "Row is " + fila.getValue() + " e a chave " + fila.getKey());

}

} captura (CouchbaseLiteException e) {

e.printStackTrace();

}

});

Consulta ao vivo.iniciar();

}

Até o momento, você deve ter 20 documentos no Sync Gateway e pode verificar isso no painel do administrador. Reinicie o aplicativo e isso criará o documento de perfil e o enviará ao Sync Gateway para importar 20 locais em torno da localização do usuário. Isso resultará na adição de 20 novos locais ao Sync Gateway:Observe que o Sync Gateway agora tem 41 documentos (o documento de perfil e mais 20 locais na localização do dispositivo que está executando o aplicativo) e o LiveQuery no aplicativo Android retorna os mesmos documentos por cidade (neste exemplo, 20 em Londres e 20 em Saint-Étienne-de-Tinée).

Alteração da função de sincronização

Até agora, você tem seguido o tutorial sem criar usuários. Ou seja, todos os dispositivos móveis que se conectam ao Sync Gateway recebem os mesmos documentos. Isso não é gerenciável à medida que o tamanho dos dados aumenta. Além disso, se um usuário estiver localizado em Saint-Étienne-de-Tinée, não há necessidade de sincronizar lugares em Londres com o dispositivo dele. Para adicionar essa filtragem de documentos por dispositivo, você fará duas coisas:

Crie usuários e autentique-se como um usuário específico.
Atualize a função de sincronização para dar a um determinado usuário acesso aos documentos na cidade em que ele está localizado.

Para criar um usuário, você usará o curl para enviar uma solicitação POST na porta de administração:

$ curl -vX POST :4985/db/_user/ 
        -H 'Content-Type: application/json' 
        -d '{"name": "james", "password": "letmein"}'

$ enrolar -vX POST :4985/db/_usuário/

-H 'Content-Type: application/json'

-d '{"name": "james", "password": "letmein"}'

No aplicativo Android, atualize o startSync método em SyncManager.java com o autenticador básico passando as mesmas credenciais:

private void startSync() {
    URL url = null;
    try {
        url = new URL(SYNC_URL);
    } catch (MalformedURLException e) {
        e.printStackTrace();
    }
    Authenticator authenticator = new BasicAuthenticator("james", "letmein");
    
    Replication push = database.createPushReplication(url);
    push.setContinuous(true);
    push.setAuthenticator(authenticator);
    push.start();
    
    Replication pull = database.createPullReplication(url);
    pull.setContinuous(true);
    pull.setAuthenticator(authenticator);
    pull.start();
}

privado vazio startSync() {

URL url = nulo;

tentar {

url = novo URL(SYNC_URL);

} captura (ExceçãoURLE malformada e) {

e.printStackTrace();

}

Autenticador autenticador = novo BasicAuthenticator("james", "letmein");

Replicação empurrar = banco de dados.createPushReplication(url);

empurrar.setContinuous(verdadeiro);

empurrar.setAuthenticator(autenticador);

empurrar.iniciar();

Replicação puxar = banco de dados.createPullReplication(url);

puxar.setContinuous(verdadeiro);

puxar.setAuthenticator(autenticador);

puxar.iniciar();

}

Navegue até a seção Sincronização no painel de controle do administrador: http://localhost:4985/_admin/db/db/syncUpdate a função Sync com o seguinte:

function(doc, oldDoc) {
        if (doc.type == "profile") {
          channel(doc.city);
          access(doc._id, doc.city);
        } else if (doc.type == "city") {
            channel(doc.city);
        }
      }

função(doc, oldDoc) {

se (doc.tipo == "profile" (perfil)) {

canal(doc.cidade);

acesso(doc._id, doc.cidade);

} mais se (doc.tipo == "cidade") {

canal(doc.cidade);

}

Em seguida, clique no ícone Modo de visualização ao vivo e o banner superior deverá ficar amarelo.Isso significa que você pode testar a função de sincronização em documentos aleatórios, mas nada foi implantado ainda; isso serve apenas para testar o resultado. Use o botão aleatório para ver a saída do canal/acesso com um documento aleatório como entrada:Para implementar de fato essa nova função de sincronização, é recomendável interromper o Sync Gateway, atualizar o arquivo de configuração e iniciá-lo novamente. Depois de reiniciar o Sync Gateway, desinstale o aplicativo do dispositivo e execute-o novamente. Você deverá notar que os mesmos 40 documentos estão sendo replicados. Na verdade, você atualizou a Sync Function, mas os documentos que foram mantidos até agora não tiveram a chance de passar pela nova Sync Function. Para corrigir isso, você usará a função ressincronização na seção a seguir.

Ressincronização

Sempre que você modificar a função Sync, certifique-se de chamar a função _resync para recalcular as regras de acesso ao canal para todos os documentos existentes no banco de dados:

$ curl -vX POST http://localhost:4985/db/_resync

1	$ enrolar -vX POST http://localhost:4985/db/_resync

Exclua o aplicativo e reinicie-o. Dessa vez, você verá apenas os 20 locais no LogCat porque o usuário está localizado em Saint-Étienne-de-Tinée e esse usuário não tem acesso ao Londres e, portanto, não obterá esses documentos.

Conclusão

Neste tutorial, você aprendeu a usar um webhook para importar documentos de uma API de terceiros para o Sync Gateway usando um App Server. Você também usou o ressincronização ao alterar sua Sync Function para atualizar o acesso aos canais.

James Nocentini, redator técnico, celular, Couchbase

Compartilhe este artigo

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

Couchbase Mobile: Alterando o acesso de leitura na função Sync e replicando as alterações em um aplicativo Android

Primeiros passos

Webhook do gateway de sincronização

Servidor de aplicativos

Criação do aplicativo Android

Alteração da função de sincronização

Ressincronização

Conclusão

Receba atualizações do blog do Couchbase em sua caixa de entrada

Autor

Postado por James Nocentini, redator técnico, celular, Couchbase

Deixe um comentário Cancelar resposta

Pronto para começar a usar o Couchbase Capella?

Iniciar a construção

Use o Capella gratuitamente

Entre em contato