sincronizar - recuperar senha exchange iphone




Como sincronizar os dados do nĂșcleo do iPhone com o servidor da Web e, em seguida, enviar para outros dispositivos? (6)

Eu tenho trabalhado em um método para sincronizar dados de núcleo armazenados em um aplicativo do iPhone entre vários dispositivos, como um iPad ou um Mac. Não há muitos (se houver algum) frameworks de sincronização para uso com Core Data no iOS. No entanto, tenho pensado no seguinte conceito:

  1. Uma alteração é feita no armazenamento de dados do núcleo local e a alteração é salva. (a) Se o dispositivo estiver online, ele tentará enviar o conjunto de alterações para o servidor, incluindo o ID do dispositivo que enviou o conjunto de alterações. (b) Se o conjunto de alterações não atingir o servidor ou se o dispositivo não estiver on-line, o aplicativo adicionará o conjunto de mudanças a uma fila para envio quando estiver on-line.
  2. O servidor, sentado na nuvem, mescla os conjuntos de mudanças específicos que recebe com seu banco de dados mestre.
  3. Depois que um conjunto de mudanças (ou uma fila de conjuntos de mudanças) é mesclado no servidor de nuvem, o servidor envia todos esses conjuntos de mudanças para os outros dispositivos registrados no servidor usando algum tipo de sistema de pesquisa. (Eu pensei em usar serviços Push da Apple, mas aparentemente, de acordo com os comentários, este não é um sistema viável.)

Existe alguma fantasia que eu precise estar pensando? Eu olhei para estruturas REST como ObjectiveResource , Core Resource e RestfulCoreData . Claro, todos eles estão trabalhando com o Ruby on Rails, ao qual eu não estou vinculado, mas é um lugar para começar. Os principais requisitos que tenho para minha solução são:

  1. Quaisquer alterações devem ser enviadas em segundo plano sem pausar o thread principal.
  2. Deve usar o mínimo de largura de banda possível.

Eu pensei em vários desafios:

  1. Certificando-se de que os IDs de objeto para os diferentes armazenamentos de dados em dispositivos diferentes estejam anexados no servidor. Ou seja, terei uma tabela de IDs de objetos e IDs de dispositivos, que são vinculados por meio de uma referência ao objeto armazenado no banco de dados. Eu terei um registro (DatabaseId [exclusivo para essa tabela], ObjectId [exclusivo para o item no banco de dados inteiro], Datafield1, Datafield2), o campo ObjectId fará referência a outra tabela, AllObjects: (ObjectId, DeviceId, DeviceObjectId). Então, quando o dispositivo envia um conjunto de alterações, ele passa o ID do dispositivo e o objectId do objeto de dados do núcleo no armazenamento de dados local. Em seguida, meu servidor de nuvem verificará o Id do objeto e do dispositivo na tabela AllObjects e localizará o registro a ser alterado na tabela inicial.
  2. Todas as alterações devem ter registro de data e hora, para que possam ser mescladas.
  3. O dispositivo terá que pesquisar o servidor, sem usar muita bateria.
  4. Os dispositivos locais também precisarão atualizar qualquer item mantido na memória se / quando as alterações forem recebidas do servidor.

Há mais alguma coisa que eu estou sentindo falta aqui? Que tipos de estruturas devo olhar para tornar isso possível?


2017

Em relação a esta questão incrivelmente antiga.

Seria muito parecido com perguntar

"Eu quero comprar um dispositivo que é um telefone que eu possa carregar comigo - mas também use para muitas tarefas de computação, mesmo navegando na WWW!"

Obviamente, a resposta para isso é se você esteve em Marte, uma das principais tecnologias realizadas neste planeta recentemente foi "smart phones", compre um.

Atualmente, criar um sistema OCC do zero seria tão insano quanto criar um banco de dados SQL a partir do zero.

Obviamente, para OCC, que é o paradigma básico de todos os aplicativos não-triviais agora, você usa

  • Firebase
  • PubNub
  • Couchbase

e assim por diante, que são simplesmente o maior avanço na tecnologia humana dos últimos anos .

Hoje, você não criaria mais OCC do zero do que faria

  • escreva seu próprio sistema operacional a partir do zero

  • escreva seu próprio banco de dados SQL a partir do zero

  • escreva sua própria fonte de renderização a partir do zero

Note que, de fato, em um sentido profissional, você não pode mais ser "um programador ios" ou "um programador android".

Quem se importa em saber como diagramar tabelas e botões?

Você é um especialista do Firebase / qualquer um, e como um problema secundário acidental, você sabe como configurar botões, etc. no ios ou no android.

O único problema é que o BAAS usar - por exemplo, talvez o PlayFab, se for orientado para o jogo, talvez o PubNub, se for realmente dirigido por mensagens, talvez ably.io, talvez kinvey, se você for corporativo - qualquer coisa.


Acabei de postar a primeira versão da minha nova API do Core Data Cloud Syncing, conhecida como SynCloud. O SynCloud tem muitas diferenças com o iCloud porque permite a interface de sincronização multiusuário. Também é diferente de outras APIs de sincronização porque permite dados relacionais de várias tabelas.

Por favor, descubra mais em http://www.syncloudapi.com

Construa com o iOS 6 SDK, está muito atualizado em 27/09/2012.


Eu fiz algo parecido com o que você está tentando fazer. Deixe-me dizer o que aprendi e como fiz isso.

Eu suponho que você tenha um relacionamento um-para-um entre o seu objeto Core Data e o modelo (ou esquema db) no servidor. Você simplesmente deseja manter o conteúdo do servidor em sincronia com os clientes, mas os clientes também podem modificar e adicionar dados. Se eu acertei, continue lendo.

Eu adicionei quatro campos para ajudar na sincronização:

  1. sync_status - Adicione este campo somente ao seu modelo de dados principal. Ele é usado pelo aplicativo para determinar se você tem uma alteração pendente no item. Eu uso os seguintes códigos: 0 significa que não há alterações, 1 significa que está na fila para ser sincronizado com o servidor e 2 significa que é um objeto temporário e pode ser limpo.
  2. is_deleted - Adicione isso ao servidor e ao modelo de dados principal. Excluir evento não deve realmente excluir uma linha do banco de dados ou do seu modelo de cliente, pois não deixa nada para sincronizar de volta. Por ter este sinalizador booleano simples, você pode definir is_deleted para 1, sincronizá-lo e todos ficarão felizes. Você também deve modificar o código no servidor e no cliente para consultar itens não excluídos com "is_deleted = 0".
  3. last_modified - Adicione isso ao servidor e ao modelo de dados principal. Esse campo deve ser atualizado automaticamente com a data e a hora atuais pelo servidor sempre que algo mudar nesse registro. Nunca deve ser modificado pelo cliente.
  4. guid - Adicione um campo id exclusivo global (consulte http://en.wikipedia.org/wiki/Globally_unique_identifier ) ao servidor e ao modelo de dados principal. Esse campo se torna a chave primária e se torna importante ao criar novos registros no cliente. Normalmente, sua chave primária é um número inteiro incremental no servidor, mas devemos ter em mente que o conteúdo pode ser criado off-line e sincronizado posteriormente. O GUID nos permite criar uma chave estando offline.

No cliente, adicione o código para definir sync_status como 1 no seu objeto de modelo sempre que algo mudar e precisar ser sincronizado com o servidor. Novos objetos de modelo devem gerar um GUID.

A sincronização é uma solicitação única. O pedido contém:

  • O registro de data e hora MAX last_modified de seus objetos de modelo. Isso informa ao servidor que você deseja apenas alterações após esse registro de data e hora.
  • Um array JSON contendo todos os itens com sync_status = 1.

O servidor recebe a solicitação e faz isso:

  • Ele pega o conteúdo do array JSON e modifica ou adiciona os registros que ele contém. O campo last_modified é atualizado automaticamente.
  • O servidor retorna um array JSON contendo todos os objetos com um registro de data e hora last_modified maior que o registro de data e hora enviado na solicitação. Isso incluirá os objetos que acabou de receber, o que serve como um reconhecimento de que o registro foi sincronizado com êxito para o servidor.

O aplicativo recebe a resposta e faz isso:

  • Ele pega o conteúdo do array JSON e modifica ou adiciona os registros que ele contém. Cada registro é definido como um sync_status de 0.

Espero que isso ajude. Eu usei a palavra registro e modelo de forma intercambiável, mas acho que você entendeu a ideia. Boa sorte.


Observe o usuário para atualizar dados via notificação push. Use um thread de fundo no aplicativo para verificar os dados locais e os dados no servidor de nuvem, enquanto a mudança acontece no servidor, altere os dados locais, vice-versa.

Então, acho que a parte mais difícil é estimar os dados em que lado está invalidado.

Espero que isso possa ajudar você



Semelhante a @Cris Eu implementei classe para sincronização entre cliente e servidor e resolvi todos os problemas conhecidos até agora (envio / recebimento de dados para / do servidor, mesclar conflitos com base em registros de data e hora, remover entradas duplicadas em condições de rede não confiáveis, sincronizar dados aninhados e arquivos etc ..)

Você apenas diz à classe qual entidade e quais colunas ela deve sincronizar e onde está seu servidor.

M3Synchronization * syncEntity = [[M3Synchronization alloc] initForClass: @"Car"
                                                              andContext: context
                                                            andServerUrl: kWebsiteUrl
                                             andServerReceiverScriptName: kServerReceiverScript
                                              andServerFetcherScriptName: kServerFetcherScript
                                                    ansSyncedTableFields:@[@"licenceNumber", @"manufacturer", @"model"]
                                                    andUniqueTableFields:@[@"licenceNumber"]];


syncEntity.delegate = self; // delegate should implement onComplete and onError methods
syncEntity.additionalPostParamsDictionary = ... // add some POST params to authenticate current user

[syncEntity sync];

Você pode encontrar a fonte, o exemplo de trabalho e mais instruções aqui: github.com/knagode/M3Synchronization .