software - no puedo enviar correos de mi iphone 6

¿Cómo sincronizar los datos principales del iPhone con el servidor web y luego enviarlos a otros dispositivos? (9)

He estado trabajando en un método para sincronizar los datos centrales almacenados en una aplicación de iPhone entre varios dispositivos, como un iPad o una Mac. No hay muchos marcos de sincronización (si es que hay alguno) para usar con Core Data en iOS. Sin embargo, he estado pensando en el siguiente concepto:

Se realiza un cambio en el almacén de datos central local y se guarda el cambio. (a) Si el dispositivo está en línea, intenta enviar el conjunto de cambios al servidor, incluida la ID del dispositivo que envió el conjunto de cambios. (b) Si el conjunto de cambios no llega al servidor, o si el dispositivo no está en línea, la aplicación agregará el conjunto de cambios a una cola para enviar cuando se conecte.
El servidor, sentado en la nube, combina los conjuntos de cambios específicos que recibe con su base de datos maestra.
Después de fusionar un conjunto de cambios (o una cola de conjuntos de cambios) en el servidor de la nube, el servidor envía todos esos conjuntos de cambios a los otros dispositivos registrados con el servidor utilizando algún tipo de sistema de sondeo. (Pensé en usar los servicios Push de Apple, pero al parecer, según los comentarios, este no es un sistema viable).

¿Hay algo lujoso en lo que deba estar pensando? He examinado los marcos de REST como ObjectiveResource , Core Resource y RestfulCoreData . Por supuesto, todos estos están trabajando con Ruby on Rails, a los que no estoy atado, pero es un lugar para comenzar. Los principales requisitos que tengo para mi solución son:

Cualquier cambio debe enviarse en segundo plano sin pausar el hilo principal.
Debe utilizar el menor ancho de banda posible.

He pensado en una serie de desafíos:

Asegurarse de que los ID de objeto para los diferentes almacenes de datos en diferentes dispositivos estén conectados en el servidor. Es decir, tendré una tabla de ID de objetos e ID de dispositivos, que se vinculan mediante una referencia al objeto almacenado en la base de datos. Tendré un registro (DatabaseId [exclusivo de esta tabla], ObjectId [exclusivo del elemento en toda la base de datos], Datafield1, Datafield2), el campo ObjectId hará referencia a otra tabla, AllObjects: (ObjectId, DeviceId, DeviceObjectId). Luego, cuando el dispositivo empuja un conjunto de cambios, pasará a lo largo de la identificación del dispositivo y el objectId del objeto de datos del núcleo en el almacén de datos local. Luego, mi servidor en la nube verificará el ID de objeto y el ID del dispositivo en la tabla de Todos los objetos, y encontrará el registro para cambiar en la tabla inicial.
Todos los cambios deben tener una marca de tiempo, para que puedan combinarse.
El dispositivo tendrá que sondear el servidor, sin consumir demasiada batería.
Los dispositivos locales también necesitarán actualizar todo lo que se encuentre en la memoria si / cuando se reciben los cambios del servidor.

¿Hay algo más que me esté perdiendo aquí? ¿Qué tipos de marcos debo mirar para hacer esto posible?

2017

Respecto a esta pregunta increíblemente antigua.

Sería muy parecido a preguntar.

"Quiero comprar un dispositivo que es un teléfono que puedo llevar conmigo, pero también usarlo para muchas tareas informáticas, ¡incluso para navegar por la WWW!"

Obviamente, la respuesta a esa pregunta es si usted ha estado en Marte, una de las principales tecnologías desarrolladas en este planeta recientemente fue "teléfonos inteligentes", compre uno.

En estos días, crear un sistema OCC desde cero sería tan insano como crear una base de datos SQL desde cero.

Obviamente, para OCC, que es el paradigma base de todas las aplicaciones no triviales ahora, usas

Base de fuego
PubNub
Base de sofá

y así sucesivamente, que son , simplemente, el mayor avance en tecnología humana de los últimos años .

Hoy en día, no crearías OCC desde cero como lo harías

escribe tu propio sistema operativo desde cero
escribe tu propia base de datos SQL desde cero
escribe tu propia fuente de renderizado desde cero

Tenga en cuenta que de hecho, en un sentido profesional, ya no puede ser "un programador de iOS" o "un programador de Android".

¿A quién le importa saber cómo diseñar tablas y botones?

Eres un experto en Firebase / lo que sea, y como problema secundario adicional, sabes cómo diseñar botones, etc. en iOS o Android.

El único problema es qué BAAS debe usar, por ejemplo, tal vez PlayFab si está orientado a los juegos, quizás a PubNub si realmente está impulsado por mensajes, quizás ably.io, tal vez kinvey si es corporativo, lo que sea.

Acabo de publicar la primera versión de mi nueva API de sincronización de Core Data Cloud, conocida como SynCloud. SynCloud tiene muchas diferencias con iCloud porque permite la interfaz de sincronización multiusuario. También es diferente de otras API de sincronización porque permite datos relacionales de múltiples tablas.

Obtenga más información en http://www.syncloudapi.com

Construido con iOS 6 SDK, está muy actualizado al 27/9/2012.

Aviso al usuario para actualizar los datos a través de notificación de inserción. Use un hilo de fondo en la aplicación para verificar los datos locales y los datos en el servidor de la nube, mientras el cambio ocurre en el servidor, cambie los datos locales, y viceversa.

Así que creo que la parte más difícil es estimar los datos en qué lado se invalida.

Espero que esto pueda ayudarte

Creo que una buena solución al problema de GUID es el "sistema de ID distribuido". No estoy seguro de cuál es el término correcto, pero creo que eso es lo que usaban los documentos de MS SQL Server (SQL usa / usa este método para bases de datos distribuidas / sincronizadas). Es bastante simple:

El servidor asigna todas las identificaciones. Cada vez que se realiza una sincronización, lo primero que se comprueba es "¿Cuántos ID me quedan en este cliente?" Si el cliente se está agotando, le pide al servidor un nuevo bloque de ID. Luego, el cliente usa ID en ese rango para nuevos registros. Esto funciona muy bien para la mayoría de las necesidades, si puede asignar un bloque lo suficientemente grande como para que "nunca" se agote antes de la próxima sincronización, pero no tan grande como para que el servidor se agote con el tiempo. Si el cliente se agota, el manejo puede ser bastante simple, solo dile al usuario "lo siento, no puedes agregar más elementos hasta que sincronices" ... si están agregando tantos elementos, ¿no deberían sincronizarse para evitar datos obsoletos? problemas de todos modos?

Creo que esto es superior al uso de GUID aleatorios porque los GUID aleatorios no son seguros al 100% y, por lo general, deben ser mucho más largos que un ID estándar (128 bits frente a 32 bits). Por lo general, tiene índices por ID y con frecuencia mantiene los números de ID en la memoria, por lo que es importante mantenerlos pequeños.

Realmente no quería publicar como respuesta, pero no sé si alguien lo vería como un comentario, y creo que es importante para este tema y no está incluido en otras respuestas.

He hecho algo similar a lo que estás tratando de hacer. Déjame decirte lo que he aprendido y cómo lo hice.

Supongo que tiene una relación de uno a uno entre su objeto de Datos Core y el modelo (o esquema de db) en el servidor. Simplemente desea mantener los contenidos del servidor sincronizados con los clientes, pero los clientes también pueden modificar y agregar datos. Si lo hice bien, entonces sigue leyendo.

Agregué cuatro campos para ayudar con la sincronización:

sync_status : agregue este campo solo a su modelo de datos principal. La aplicación la utiliza para determinar si tiene un cambio pendiente en el elemento. Utilizo los siguientes códigos: 0 significa que no hay cambios, 1 significa que está en cola para sincronizarse con el servidor y 2 significa que es un objeto temporal y se puede eliminar.
is_deleted : agregue esto al servidor y al modelo de datos principales. El evento de eliminación no debería eliminar realmente una fila de la base de datos o de su modelo de cliente porque no le deja nada para sincronizar. Al tener esta simple bandera booleana, puede establecer is_deleted en 1, sincronizarlo y todos estarán felices. También debe modificar el código en el servidor y el cliente para consultar los elementos no eliminados con "is_deleted = 0".
last_modified : agregue esto al servidor y al modelo de datos principales. Este campo debe ser actualizado automáticamente con la fecha y hora actual por el servidor cada vez que algo cambie en ese registro. Nunca debe ser modificado por el cliente.
guid : agrega un campo de identificación único global (ver http://en.wikipedia.org/wiki/Globally_unique_identifier ) al servidor y al modelo de datos principales. Este campo se convierte en la clave principal y se vuelve importante al crear nuevos registros en el cliente. Normalmente, su clave principal es un entero incremental en el servidor, pero debemos tener en cuenta que el contenido se puede crear sin conexión y sincronizarse más tarde. El GUID nos permite crear una clave mientras estamos fuera de línea.

En el cliente, agregue el código para configurar sync_status a 1 en su objeto modelo siempre que algo cambie y deba sincronizarse con el servidor. Los nuevos objetos modelo deben generar un GUID.

La sincronización es una única solicitud. La solicitud contiene:

La marca de tiempo MAX last_modified de sus objetos modelo. Esto le indica al servidor que solo desea cambios después de esta marca de tiempo.
Una matriz JSON que contiene todos los elementos con sync_status = 1.

El servidor recibe la solicitud y hace esto:

Toma el contenido de la matriz JSON y modifica o agrega los registros que contiene. El campo last_modified se actualiza automáticamente.
El servidor devuelve una matriz JSON que contiene todos los objetos con una marca de tiempo last_modified mayor que la marca de tiempo enviada en la solicitud. Esto incluirá los objetos que acaba de recibir, lo que sirve como un acuse de recibo de que el registro se sincronizó correctamente con el servidor.

La aplicación recibe la respuesta y hace esto:

Toma el contenido de la matriz JSON y modifica o agrega los registros que contiene. Cada registro se establece un sync_status de 0.

Espero que eso ayude. Usé el registro de palabras y el modelo indistintamente, pero creo que entiendes la idea. Buena suerte.

Primero debes repensar cuántos datos, tablas y relaciones tendrás. En mi solución he implementado la sincronización a través de archivos de Dropbox. Observo los cambios en el MOC principal y guardo estos datos en archivos (cada fila se guarda como gzipped json). Si hay una conexión a Internet funcionando, verifico si hay cambios en Dropbox (Dropbox me da cambios delta), los descargo y fusiono (últimas victorias), y finalmente pongo los archivos modificados. Antes de sincronizar, coloco el archivo de bloqueo en Dropbox para evitar que otros clientes sincronicen datos incompletos. Al descargar cambios, es seguro que solo se descarguen datos parciales (p. Ej., Pérdida de conexión a Internet). Cuando finaliza la descarga (total o parcial), comienza a cargar archivos en Core Data. Cuando hay relaciones no resueltas (no se descargan todos los archivos), deja de cargar archivos e intenta finalizar la descarga más tarde. Las relaciones se almacenan solo como GUID, por lo que puedo verificar fácilmente qué archivos cargar para tener la integridad completa de los datos. La sincronización se inicia después de que se realizan cambios en los datos básicos. Si no hay cambios, comprueba los cambios en Dropbox cada pocos minutos y en el inicio de la aplicación. Además, cuando se envían cambios al servidor, envío una transmisión a otros dispositivos para informarles sobre los cambios, para que puedan sincronizarse más rápido. Cada entidad sincronizada tiene propiedad GUID (guid se usa también como un nombre de archivo para intercambiar archivos). También tengo una base de datos de sincronización donde almaceno la revisión de Dropbox de cada archivo (puedo compararlo cuando el delta de Dropbox restablece su estado). Los archivos también contienen el nombre de la entidad, el estado (eliminado / no eliminado), guid (igual que el nombre de archivo), la revisión de la base de datos (para detectar migraciones de datos o para evitar la sincronización con las versiones nunca de la aplicación) y, por supuesto, los datos (si no se elimina la fila).

Esta solución está funcionando para miles de archivos y alrededor de 30 entidades. En lugar de Dropbox, podría usar el almacén de clave / valor como el servicio web REST que quiero hacer más tarde, pero no tengo tiempo para esto :) Por ahora, en mi opinión, mi solución es más confiable que iCloud y, lo que es muy importante, Tengo control total sobre cómo funciona (principalmente porque es mi propio código).

Otra solución es guardar los cambios MOC como transacciones: habrá menos archivos intercambiados con el servidor, pero es más difícil realizar la carga inicial en el orden correcto en los datos del núcleo vacío. iCloud funciona de esta manera, y también otras soluciones de sincronización tienen un enfoque similar, por ejemplo, TICoreDataSync .

- ACTUALIZACIÓN

Después de un tiempo, migré a Ensembles . Recomiendo esta solución para reinventar la rueda.

Si aún estás buscando un camino por recorrer, busca en el móvil Couchbase. Esto básicamente hace todo lo que quieres. ( http://www.couchbase.com/nosql-databases/couchbase-mobile )

Similar a @Cris. He implementado la clase para la sincronización entre el cliente y el servidor y resolví todos los problemas conocidos hasta ahora (enviar / recibir datos al servidor, fusionar conflictos basados en marcas de tiempo, eliminar entradas duplicadas en condiciones de red no confiables, sincronizar datos anidados y archivos etc ..)

Simplemente le dice a la clase qué entidad y qué columnas deben sincronizarse y dónde está su 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];

Puede encontrar la fuente, el ejemplo de trabajo y más instrucciones aquí: github.com/knagode/M3Synchronization .

Sugiero leer detenidamente e implementar la estrategia de sincronización discutida por Dan Grover en la conferencia de iPhone 2009, disponible here como un documento pdf.

Esta es una solución viable y no es tan difícil de implementar (Dan implementó esto en varias de sus aplicaciones), superponiendo la solución descrita por Chris. Para una discusión teórica profunda sobre la sincronización, vea el documento de Russ Cox (MIT) y William Josephson (Princeton):

Sincronización de archivos con Vector Time Pairs

que se aplica igualmente bien a los datos básicos con algunas modificaciones obvias. Esto proporciona una estrategia de sincronización global mucho más robusta y confiable, pero requiere más esfuerzo para implementarse correctamente.

EDITAR:

Parece que el archivo pdf de Grover ya no está disponible (enlace roto, marzo de 2015). ACTUALIZACIÓN: el enlace está disponible a través de Way Back Machine here

El marco de trabajo de Objective-C llamado ZSync y desarrollado por Marcus Zarra ha quedado en desuso, dado que iCloud finalmente parece admitir la correcta sincronización de los datos del núcleo.