Share data between iOS Apps & App Extensions across devices

Esta postagem discute como usar o Couchbase Mobile para compartilhar dados entre seu aplicativo iOS e sua extensão de aplicativo iOS entre dispositivos. Em um artigo anterior postagemEm nosso artigo, discutimos como você pode usar o Couchbase Lite como um armazenamento de dados autônomo e incorporado para compartilhar dados entre seu aplicativo iOS e sua extensão de aplicativo no mesmo dispositivo. Nesta postagem, vamos estender isso para aproveitar o Sync Gateway e permitir a sincronização de dados entre os aplicativos e a extensão de aplicativo correspondente nos dispositivos iOS.

OBSERVAÇÃO: usaremos Couchbase Lite v1.4.1 que é a versão de produção atual. Mas tudo o que discutimos aqui se aplica à versão mais recente Versão 2.0 do Developer Preview do Couchbase Mobile.

Histórico

Presumo que você esteja familiarizado com o desenvolvimento de aplicativos iOS em Swift e tenha um conhecimento básico da integração do Couchbase Lite em seu aplicativo iOS. Esse Guia de introdução é um ótimo lugar para começar.

Se você ainda não o fez, leia isto postagem de blog relacionada sobre os conceitos básicos do App Extensions e como configurar seu aplicativo para oferecer suporte a ele.

Como na postagem anterior, discutiremos como o Couchbase Mobile pode ser usado com uma extensão Today. Esse tipo de extensão, também conhecido como "Widget", aparece na visualização Today da Central de Notificações e permite que os usuários obtenham atualizações rápidas.

Couchbase Lite

O Couchbase Lite é um banco de dados incorporado que é executado em dispositivos. Ele pode ser usado em vários modos de implantação. Pode ser usado como um banco de dados incorporado autônomo ou pode ser usado em conjunto com um Sync Gateway remoto que permita a sincronização de dados entre dispositivos. Nesta postagem, não abordaremos os detalhes da integração com o Couchbase Lite. O Primeiros passos com o Couchbase Lite é um bom lugar para começar a fazer isso.

Gateway de sincronização

O Sync Gateway é um componente voltado para a Internet ao qual seus aplicativos móveis se conectam. Ele é responsável pela sincronização de dados entre os clientes, pelo roteamento e pela autorização. Ele pode ser configurado para manter os dados em um Servidor Couchbase. Nesta postagem, usaremos o Couchbase Server em "morsa" em que os dados são mantidos na memória. Em outras palavras, neste aplicativo de demonstração, nosso Sync Gateway não terá o suporte do Couchbase Server. Isso é adequado para fins de desenvolvimento. Em um aplicativo do mundo real, você provavelmente desejará manter seus dados em um servidor.

Exemplo de aplicativo de lista de tarefas

Baixe o projeto de amostra do Github e mude para suporte à sincronização ramo.

 git clone git@github.com:couchbaselabs/couchbase-mobile-ios-app-extension.git

1	git clone git@github.com:couchbaselabs/couchbase-móvel-ios-aplicativo-extensão.git

git checkout syncsupport

1	git checkout suporte à sincronização

Nosso aplicativo de amostra é um aplicativo simples de lista de tarefas que permite aos usuários adicionar, editar e excluir tarefas. Um usuário pode marcar tarefas como concluídas. Uma extensão Today é fornecida com o aplicativo que mostra as duas principais tarefas diretamente na central de notificações, sem a necessidade de abrir o aplicativo. O usuário pode marcar as tarefas como concluídas diretamente na central de notificações.

Todas as tarefas são armazenadas em um banco de dados local do Couchbase Lite e sincronizadas com o Sync Gateway remoto para que as alterações sejam disponibilizadas para aplicativos/extensões de aplicativos em outros dispositivos.

Isso implica que o aplicativo contêiner e a extensão precisarão acessar o banco de dados do Couchbase Lite, que é sincronizado com o Sync Gateway.

Instalação/execução do Sync Gateway

Primeiro, Faça o download e instale o Sync

Gateway, caso ainda não o tenha feito.
Iniciaremos o Sync Gateway com o comando Exemplo de arquivo de configuração que você baixou do repositório do aplicativo de amostra.
Vamos primeiro abrir e revisar o conteúdo de Exemplo de arquivo de configuração

{
 "log": ["*"],
 "CORS": {
 "Origin":["*"]
 },
 "databases": {
 "demo": {
      "server": "walrus:",
      "bucket": "default",
      "users": { "GUEST": { "disabled": false, "admin_channels": ["*"] } },
      "unsupported": {
         "user_views": {
               "enabled":true
              }
        }
     }
  }
 }

{

"log": ["*"],

"CORS": {

"Origem":["*"]

"bancos de dados": {

"demo": {

"servidor": "walrus:",

"bucket" (balde): "default",

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

"sem suporte": {

"user_views": {

"habilitado":verdadeiro

}

Alguns itens dignos de nota
- O nome do banco de dados é demonstração
- O Sync Gateway está configurado para ser implantado em morsa modo. Observe que isso é adequado apenas para fins de desenvolvimento.
- Nós habilitamos convidado acesso. Observe que isso é adequado apenas para fins de desenvolvimento. Em um aplicativo do mundo real, você deve desativar o acesso de convidados.

Primeiro, vá para a pasta na qual você clonou o repositório do aplicativo de amostra.

 cd /path/to/couchbase-mobile-ios-app-extension

1	cd /caminho/para/couchbase-móvel-ios-aplicativo-extensão

Em seguida, inicie o Sync Gateway com o arquivo de configuração.

 /path/to/sync-gateway sync-gateway-config.json

1	/caminho/para/sincronização-portal sincronização-portal-configuração.json

Arquitetura

As extensões de aplicativos não são aplicativos autônomos. Elas são agrupadas em um aplicativo, chamado de Aplicativo de contêineres. Embora as App Extensions sejam agrupadas no aplicativo Container, elas são executadas independentemente do aplicativo Container em um processo separado. As extensões de aplicativos são iniciadas por outros aplicativos que precisam da funcionalidade da extensão. O aplicativo que inicia a extensão de aplicativo é chamado de Aplicativo host. A interface do usuário da extensão é exibida no contexto do aplicativo host.

Em nosso aplicativo de amostra, o CBLiteTaskExtension é o widget Today do tipo App Extension e CBLiteTaskApp é o aplicativo contêiner correspondente. O sistema Centro de Notificação é efetivamente o aplicativo host da nossa extensão de aplicativo.

Embora o aplicativo de contêiner e a extensão correspondente sejam processos independentes executados em sua própria área restrita, eles podem compartilhar dados por meio de um Contêiner compartilhado.

Portanto, isso implica que, se nosso banco de dados do Couchbase Lite estiver localizado no diretório Contêiner compartilhadoque permitiria a ambos CBLiteTaskExtension e CBLiteTaskApp para ter acesso a ele. O banco de dados Couchbase Lite é então responsável por enviar as alterações para o Sync Gateway da maneira usual, independentemente de o conteúdo ter sido atualizado localmente pelo aplicativo ou pelo widget Today. Da mesma forma, as alterações extraídas do Sync Gateway estão disponíveis tanto para o aplicativo quanto para o widget Today.

Configuração de um contêiner compartilhado

O Shared Container pode ser configurado registrando um Grupo de aplicativos e habilitá-lo para uso tanto pelo aplicativo contêiner quanto pela extensão de aplicativo correspondente.

Consulte as informações relacionadas postagem sobre como configurar seu aplicativo para usar "Grupos de aplicativos"

Passo a passo do aplicativo

Abra o CBLiteApp.xcworkspace usando o Xcode. Embora o aplicativo deva funcionar no Xcode 8.3 e superior, prefiro usar o Xcode 9 porque ele inclui suporte para iniciar vários simuladores, o que seria útil ao testar os recursos de sincronização entre dispositivos. Portanto, se você tiver a opção, use o Xcode 9.
Crie e execute o aplicativo em um simulador de iOS escolhendo o destino do aplicativo "CBLiteTaskApp". Agora, alterne para a exibição Hoje da Central de Notificações
Adicione seu novo widget de extensão ao Today View, conforme mostrado abaixo

Se estiver usando o Xcode 9, inicie o aplicativo em um segundo simulador e adicione o widget de extensão ao Today View, conforme mostrado anteriormente. Portanto, agora você tem dois simuladores executando o aplicativo Task List.

Em um simulador, usando o aplicativo, adicione algumas tarefas tocando no botão "+". Você as verá atualizadas no widget Hoje do segundo simulador em tempo real. Se você estiver executando um único simulador, poderá alternar para o widget Hoje no mesmo dispositivo. Você perceberá que as tarefas que adicionou são exibidas no widget.

Da mesma forma, em um simulador, marque as tarefas como "concluídas" por meio do widget Today. Você verá o status sendo atualizado no aplicativo correspondente no segundo simulador em tempo real. Se você estiver executando um único simulador, poderá alternar para o aplicativo no mesmo dispositivo. Você perceberá que o status de conclusão do

Agora, adicionaremos uma tarefa ao Sync Gateway por meio da função API REST. Você verá a nova tarefa aparecer no aplicativo e no widget de hoje em ambos os simuladores, tudo em tempo real! Muito legal!

Você pode usar qualquer cliente HTTP para fazer as chamadas à API REST para atualizar um documento no Sync Gateway. Mas eu usarei o Postman.

Abra um terminal e digite o seguinte comando curl que adiciona uma tarefa chamada "task3" ao banco de dados

 curl -X PUT http://localhost:4984/demo/task3 
 -H 'accept: application/json' 
 -H 'cache-control: no-cache' 
 -H 'content-type: application/json' 
 -d '{
 "createdOn": 1510933574.672683,
 "isCompleted": false,
 "name": "task3"
 }'

enrolar -X PUT http://localhost:4984/demo/task3

-H 'accept: application/json'

-H 'cache-control: no-cache'

-H 'content-type: application/json'

-d '{

"createdOn": 1510933574.672683,

"isCompleted": falso,

"name": "task3"

Você verá a tarefa recém-adicionada aparecer no aplicativo e no widget

Passo a passo do código

O aplicativo é arquitetado usando o [Modelo-Visão-Apresentador (MVP)] padrão.

Gerenciador de banco de dados

O Gerenciador de banco de dados é o Modeloimplementada como uma classe singleton que lida com as funções de gerenciamento do banco de dados do Couchbase Lite. Essa é a classe que inicializa o banco de dados do Couchbase Lite na classe Contêiner compartilhado portanto, agora ele está disponível para os processos do App Extension e do App

Abra o Gerenciador de banco de dados.swift e localize o arquivo appGroupContainerURL() função. Essa função cria uma pasta no diretório Contêiner compartilhado para uso pelo aplicativo

 // 1. Get URL to shared group container
 let fileManager = FileManager.default
 guard let groupURL = fileManager
 .containerURL(forSecurityApplicationGroupIdentifier: "group.com.example.CBLiteSharedData") else {
 return nil
 }
let storagePathUrl = groupURL.appendingPathComponent(&amp;quot;CBLite&amp;quot;)
let storagePath = storagePathUrl.path

// 2: Create a folder in the shared container location with name&amp;quot;CBLite&amp;quot;
if !fileManager.fileExists(atPath: storagePath) {
    do {
        try fileManager.createDirectory(atPath: storagePath,
                                        withIntermediateDirectories: false,
                                        attributes: nil)
    } catch let error {
        print(&amp;quot;error creating filepath: \(error)&amp;quot;)
        return nil
    }
}

// 1. obter URL para o contêiner de grupo compartilhado

deixar gerenciador de arquivos = Gerenciador de arquivos.padrão

guarda deixar groupURL = gerenciador de arquivos

.containerURL(forSecurityApplicationGroupIdentifier: "group.com.example.CBLiteSharedData") mais {

retorno nulo

}

deixar storagePathUrl = groupURL.appendingPathComponent(&amplificador;cotação;CBLite&amplificador;cotação;)

deixar caminho de armazenamento = storagePathUrl.caminho

// 2: crie uma pasta no local do contêiner compartilhado com o nome"CBLite"

se !gerenciador de arquivos.fileExists(atPath: caminho de armazenamento) {

fazer {

tentar gerenciador de arquivos.createDirectory(atPath: caminho de armazenamento,

comIntermediateDirectories: falso,

atributos: nulo)

} captura deixar erro {

impressão(&amplificador;cotação;erro criando caminho do arquivo: \(erro)&amplificador;cotação;)

retorno nulo

}

Retorna o URL para o contêiner de grupo compartilhado. Os contêineres de grupo são armazenados em ~/Biblioteca/Contêineres de grupo/
Crie uma pasta chamada CBLite no contêiner do grupo compartilhado.

Localize o configureCBManagerForSharedData() função. É aqui que configuramos a função Gerenciador de CBL com o URL da pasta que criamos no objeto appGroupContainerURL() função

 // 1. Set the file protection mode for the Couchbase Lite database folder
 let options = CBLManagerOptions(readOnly: false, fileProtection: Data.WritingOptions.completeFileProtectionUnlessOpen)
 let cblpoptions = UnsafeMutablePointer.allocate(capacity: 1)
 cblpoptions.initialize(to: options)
 if let url = self.appGroupContainerURL() {
    // 2. Initialize the CBLManager with the directory of the shared container
    _cbManager = try CBLManager.init(directory: url.relativePath, options: cblpoptions)
    
}

// Definir o modo de proteção de arquivo para a pasta do banco de dados do Couchbase Lite

deixar opções = CBLManagerOptions(readOnly: falso, fileProtection: Dados.WritingOptions.completeFileProtectionUnlessOpen)

deixar cblpoptions = UnsafeMutablePointer.alocar(capacidade: 1)

cblpoptions.inicializar(para: opções)

se deixar url = autônomo.appGroupContainerURL() {

// Inicialize o CBLManager com o diretório do contêiner compartilhado

_cbManager = tentar Gerenciador de CBL.inicial(diretório: url.relativePath, opções: cblpoptions)

}

Criar CBLManagerOptions com as proteções de arquivo apropriadas. Um valor de completeFileProtectionUnlessOpen implica que o acesso de leitura/gravação ao arquivo é restrito, a menos que o arquivo esteja aberto
Inicializar o Gerenciador de CBL com o caminho para o contêiner compartilhado. Posteriormente, quando o banco de dados for criado, ele será criado no contêiner compartilhado.

Localize o openOrCreateDatabaseInSharedContainer() função. É aqui que inicializamos o banco de dados do Couchbase Lite usando o CBLManager

 // 1: Set Database Options
 let options = CBLDatabaseOptions()
 options.storageType = kCBLSQLiteStorage
 options.create = true
 // 2: Create a DB for logged in user if it does not exist else return handle to existing one
  _db  = try _cbManager?.openDatabaseNamed(kDBName.lowercased(), with: options)

// 1: Definir opções do banco de dados

deixar opções = CBLDatabaseOptions()

opções.storageType = kCBLSQLiteStorage

opções.criar = verdadeiro

// 2: Criar um banco de dados para o usuário conectado, se ele não existir; caso contrário, retornar o identificador para o existente

_db = tentar _cbManager?.openDatabaseNamed(kDBName.com letras minúsculas(), com: opções)

Criar CBLDatabaseOptions objeto
Inicializar o Banco de dados CBLD usando o Gerenciador de CBL que foi criada anteriormente. Quando o banco de dados for criado, ele será criado no contêiner compartilhado especificado pelo gerente.

É isso aí! O banco de dados do Couchbase Lite está agora no contêiner compartilhado, no qual o aplicativo e a extensão podem ler e gravar.

A próxima etapa é ativar a sincronização com o Sync Gateway remoto

Localize o startDBPullReplication() função. É aqui que configuramos a função Puxar replicador para extrair dados do Sync Gateway para o banco de dados do Couchbase Lite.

 if (pullRepl == nil) {
 // 1: Create a Pull replication to start pulling from remote source
 pullRepl = _db?.createPullReplication(URL(string: self.kDBName.lowercased(), relativeTo: URL.init(string: kRemoteSyncUrl))!)
        // 2. Continuously look for changes
        _pullRepl?.continuous = true
     }

    // 3. Start the pull replicator
    _pullRepl?.start()

se (pullRepl == nulo) {

// 1: Criar uma replicação Pull para começar a extrair da fonte remota

pullRepl = _db?.createPullReplication(URL(string: autônomo.kDBName.com letras minúsculas(), relativeTo: URL.inicial(string: kRemoteSyncUrl))!)

// 2. procurar continuamente por mudanças

_pullRepl?.contínuo = verdadeiro

}

// Iniciar o replicador de tração

_pullRepl?.iniciar()

Criar CBLReplicação Puxar objeto replicador
Configure-o para extrair documentos no modo contínuo. Isso permitirá que as alterações sejam propagadas em tempo real.
Iniciar a replicação

Localize o startDBPushReplication() função. É aqui que configuramos a função Empurrar replicador para enviar dados do banco de dados do Couchbase Lite para o Sync Gateway.

 if (_pushRepl == nil) {
       // 1: Create a push replication to start pushing to remote source
        _pushRepl = _db?.createPushReplication(URL(string: self.kDBName.lowercased(), relativeTo: URL.init(string:kRemoteSyncUrl))!)

        // 2. Continuously push  changes
        _pushRepl?.continuous = true

     }

    // 3. Start the push replicator
    _pushRepl?.start()

se (_pushRepl == nulo) {

// 1: Criar uma replicação push para iniciar o push para a fonte remota

_pushRepl = _db?.createPushReplication(URL(string: autônomo.kDBName.com letras minúsculas(), relativeTo: URL.inicial(string:kRemoteSyncUrl))!)

// 2. promover mudanças continuamente

_pushRepl?.contínuo = verdadeiro

}

// Iniciar o replicador push

_pushRepl?.iniciar()

Criar CBLReplicação Empurrar objeto replicador
Configure-o para enviar documentos no modo contínuo. Isso permitirá que as alterações sejam propagadas em tempo real.
Iniciar a replicação

Depois de ativar a replicação, você adiciona observadores para serem notificados das alterações. Isso é implementado na seção addReplicationChangeObserverForReplicator() função.
Com essas etapas simples, você tem o banco de dados compartilhado do Couchbase Lite replicando alterações com o Sync Gateway remoto.

Apresentador de tarefas

O Apresentador de tarefas é o Presenter, que lida com as interações da interface do usuário tanto do CBLiteTaskExtension extensão de tarefa e o CBLiteTaskApp e faz interface com o aplicativo Gerenciador de banco de dados. Ele é o intermediário entre o aplicativo/extensão de aplicativo e o DatabaseManager.

Revisar o TaskPresenter.swift arquivo. Você verá que ele implementa as funções CRUD para interagir com o banco de dados Couchbase Lite. Mas observe que a implementação dessas funções usa a variável Gerenciador de banco de dados.

E agora?

A postagem discute como é fácil usar o Couchbase Lite como um armazenamento de dados compartilhado entre seu aplicativo iOS e o widget correspondente do aplicativo Today. Com a sincronização do banco de dados compartilhado com o Sync Gatway remoto, agora podemos replicar alterações nos aplicativos/extensões de aplicativos em vários dispositivos.

Se tiver alguma dúvida, sinta-se à vontade para entrar em contato comigo pelo Twitter @rajagp ou envie-me um e-mail priya.rajagopal@couchbase.com. Se você quiser sugerir melhorias, envie uma solicitação pull para o site GitHub repo. Você pode saber mais sobre a integração com o Couchbase Lite neste Primeiros passos com o Couchbase Lite blog.

O Fóruns do Couchbase são outro ótimo lugar para postar suas perguntas.

Priya Rajagopal, Diretora Sênior, Gerenciamento de Produtos

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

Compartilhamento e sincronização de dados entre aplicativos iOS e extensões de aplicativos entre dispositivos