jumeler - synchroniser ipad et iphone sans ordinateur




Comment synchroniser les données de base de l'iPhone avec le serveur Web, puis appuyer sur d'autres périphériques? (6)

2017

En ce qui concerne cette question incroyablement ancienne.

Cela ressemblerait beaucoup à demander

"Je veux acheter un appareil qui est un téléphone que je peux transporter avec moi - mais aussi utiliser pour de nombreuses tâches informatiques, même en naviguant sur le Web!"

Évidemment, la réponse à celle-ci est que si vous avez été sur Mars, l'une des principales technologies réalisées sur cette planète a été récemment "téléphones intelligents", en acheter un.

De nos jours, créer un système OCC à partir de zéro serait aussi fou que de créer une base de données SQL à partir de zéro.

Évidemment, pour OCC, qui est le paradigme de base de toutes les applications non triviales maintenant, vous utilisez

  • Firebase
  • PubNub
  • Couchbase

et ainsi de suite, qui sont tout simplement, le progrès majeur dans la technologie humaine de ces dernières années .

Aujourd'hui, vous ne créerez plus OCC à partir de zéro que vous le feriez

  • écrivez votre propre système d'exploitation à partir de zéro

  • écrire votre propre base de données SQL à partir de zéro

  • écrivez votre propre police-rendu à partir de zéro

Notez qu'en effet, dans un sens professionnel vous ne pouvez plus être "un programmeur ios" ou "un programmeur Android".

Qui se soucie de savoir comment mettre en page des tableaux et des boutons?

Vous êtes un expert Firebase / n'importe quel expert, et en tant que problème secondaire, vous savez comment mettre en forme les boutons, etc sur iOS ou Android.

Le seul problème est quel BAAS à utiliser - par exemple, peut-être PlayFab s'il est orienté jeu, peut-être PubNub si c'est vraiment axé sur les messages, peut-être ably.io, peut-être kinvey si vous êtes entreprise - peu importe.

J'ai travaillé sur une méthode pour synchroniser les données de base stockées dans une application iPhone entre plusieurs appareils, tels qu'un iPad ou un Mac. Il n'y a pas beaucoup de frameworks de synchronisation (le cas échéant) à utiliser avec Core Data sur iOS. Cependant, j'ai réfléchi au concept suivant:

  1. Une modification est apportée au magasin de données principal local et la modification est enregistrée. (a) Si l'appareil est en ligne, il essaie d'envoyer l'ensemble de modifications au serveur, y compris l'ID d'appareil de l'appareil qui a envoyé l'ensemble de modifications. (b) Si l'ensemble de modifications n'atteint pas le serveur, ou si l'appareil n'est pas en ligne, l'application ajoutera l'ensemble de modifications à une file d'attente à envoyer lorsqu'elle sera en ligne.
  2. Le serveur, assis dans le cloud, fusionne les jeux de modifications spécifiques qu'il reçoit avec sa base de données master.
  3. Après la fusion d'un jeu de modifications (ou d'une file d'attente de jeux de modifications) sur le serveur cloud, le serveur envoie tous ces jeux de modifications aux autres périphériques enregistrés auprès du serveur à l'aide d'un système de sondage. (J'ai pensé utiliser les services Push d'Apple, mais apparemment, selon les commentaires, ce système n'est pas réalisable.)

Y a-t-il quelque chose d'extraordinaire auquel je dois penser? J'ai examiné les frameworks REST tels que ObjectiveResource , Core Resource et RestfulCoreData . Bien sûr, tout cela fonctionne avec Ruby on Rails, auquel je ne suis pas lié, mais c'est un bon point de départ. Les principales exigences que j'ai pour ma solution sont:

  1. Toutes les modifications doivent être envoyées en arrière-plan sans interruption du thread principal.
  2. Il devrait utiliser le moins de bande passante possible.

J'ai réfléchi à un certain nombre de défis:

  1. Assurez-vous que les ID d'objet pour les différents magasins de données sur différents périphériques sont attachés sur le serveur. C'est-à-dire, je vais avoir une table d'ID d'objet et d'ID d'appareil, qui sont liés par une référence à l'objet stocké dans la base de données. Je vais avoir un enregistrement (DatabaseId [unique à cette table], ObjectId [unique à l'élément dans la base de données entière], Datafield1, Datafield2), le champ ObjectId référencera une autre table, AllObjects: (ObjectId, DeviceId, DeviceObjectId). Ensuite, lorsque le périphérique enfonce un ensemble de modifications, il transmettra l'ID du périphérique et l'ID d'objet de l'objet de données principal dans le magasin de données local. Ensuite, mon serveur cloud vérifie l'ID d'objet et l'ID de périphérique dans la table AllObjects et trouve l'enregistrement à modifier dans la table initiale.
  2. Toutes les modifications doivent être horodatées, afin qu'elles puissent être fusionnées.
  3. L'appareil devra interroger le serveur, sans utiliser trop de batterie.
  4. Les périphériques locaux devront également mettre à jour tout contenu en mémoire si / quand des modifications sont reçues du serveur.

Y a-t-il autre chose qui me manque ici? Quels types de cadres devrais-je examiner pour rendre cela possible?


Aviser l'utilisateur de mettre à jour les données via une notification push. Utilisez un fil d'arrière-plan dans l'application pour vérifier les données locales et les données sur le serveur cloud, tandis que le changement se produit sur le serveur, modifier les données locales, et vice versa.

Donc, je pense que la partie la plus difficile est d'estimer les données dans lesquelles le côté est invalide.

J'espère que cela peut vous aider


Je pense qu'une bonne solution à la question GUID est "système d'identification distribué". Je ne suis pas sûr de ce que le terme correct est, mais je pense que c'est ce que les docs du serveur MS SQL l'appelaient (SQL utilise / utilise cette méthode pour les bases de données distribuées / synchronisées). C'est plutôt simple:

Le serveur affecte tous les ID. Chaque fois qu'une synchronisation est effectuée, la première chose à vérifier est "Combien d'identifiants ai-je sur ce client?" Si le client est faible, il demande au serveur un nouveau bloc d'ID. Le client utilise ensuite les ID dans cette plage pour les nouveaux enregistrements. Cela fonctionne très bien pour la plupart des besoins, si vous pouvez assigner un bloc suffisamment grand pour qu'il ne "s'éteigne" jamais avant la prochaine synchronisation, mais pas trop grand pour que le serveur s'épuise au fil du temps. Si le client ne fonctionne plus, la gestion peut être assez simple, dites simplement à l'utilisateur "désolé que vous ne pouvez pas ajouter plus d'éléments jusqu'à ce que vous synchronisiez" ... s'ils ajoutent de nombreux éléments, ne devraient-ils pas se synchroniser des problèmes de toute façon?

Je pense que cela est supérieur à l'utilisation de GUID aléatoires car les GUID aléatoires ne sont pas sûrs à 100% et doivent généralement être beaucoup plus longs qu'un ID standard (128 bits vs 32 bits). Vous avez généralement des index par ID et gardez souvent les numéros d'identification en mémoire, il est donc important de les garder petits.

Je n'ai pas vraiment envie de poster comme réponse, mais je ne sais pas que quelqu'un verrait comme un commentaire, et je pense que c'est important pour ce sujet et non inclus dans d'autres réponses.


Je suggère de lire attentivement et de mettre en œuvre la stratégie de synchronisation discutée par Dan Grover lors de la conférence iPhone 2009, disponible here en format pdf.

Ceci est une solution viable et n'est pas si difficile à mettre en œuvre (Dan l'a implémenté dans plusieurs de ses applications), chevauchant la solution décrite par Chris. Pour une discussion théorique approfondie sur la synchronisation, voir l'article de Russ Cox (MIT) et William Josephson (Princeton):

Synchronisation de fichiers avec des paires de temps vectorielles

ce qui s'applique aussi bien aux données de base avec quelques modifications évidentes. Cela fournit une stratégie de synchronisation globale beaucoup plus robuste et fiable, mais nécessite plus d'efforts pour être implémentée correctement.

MODIFIER:

Il semble que le fichier pdf de Grover ne soit plus disponible (lien brisé, mars 2015). MISE À JOUR: le lien est disponible via le Way Back Machine here

Le framework Objective-C appelé ZSync et développé par Marcus Zarra a été abandonné, étant donné qu'iCloud semble enfin supporter une synchronisation correcte des données de base.



Similaire à @Cris J'ai implémenté la classe pour la synchronisation entre le client et le serveur et résolu tous les problèmes connus (envoyer / recevoir des données vers / depuis le serveur, fusionner les conflits en fonction des horodatages, supprimer les doublons dans des conditions réseau non fiables, fichiers etc.)

Vous dites à la classe quelle entité et quelles colonnes doit-elle synchroniser et où se trouve votre serveur.

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];

Vous pouvez trouver la source, l'exemple de travail et d'autres instructions ici: github.com/knagode/M3Synchronization .





data-synchronization