/ /

/ /

SDK de dispositivos Atlas

Node.js SDK

Sincronizar datos

Administrar una sesión de sincronización - SDK de Node.js

Los SDK de dispositivos Atlas están obsoletos. Consulte Página de desuso para más detalles.

Al usar Atlas Device Sync, el SDK de Node.js sincroniza los datos con Atlas en segundo plano mediante una sesión de sincronización. Esta sesión se inicia al abrir un dominio sincronizado.

Requisitos previos

Antes de poder administrar una sesión de sincronización, debe realizar lo siguiente:

Acceder a la sesión de sincronización

Después de abrir un reino sincronizado, puedes acceder a su sesión de sincronización con el Propiedad Realm.syncSession.

const realm = await Realm.open(config);
const syncSession = realm.syncSession;

Pausar o reanudar una sesión de sincronización

Al abrir un reino sincronizado, se inicia una sesión de sincronización. Puedes pausar y reanudar la sesión de sincronización en ese reino. Pausar una sesión de sincronización solo pausa la sesión de sincronización de ese reino. Si tienes más de un reino abierto, la pausa no afecta las sesiones de sincronización de los demás reinos.

Para pausar la sincronización, utilice el método syncSession.pause(). Para reanudarla, utilice el método syncSession.resume().

const behaviorConfiguration = {
  type: "openImmediately",
};
const config = {
  schema: [DogSchema],
  sync: {
    user: app.currentUser,
    partitionValue: "MyPartitionValue",
    newRealmFileBehavior: behaviorConfiguration,
    existingRealmFileBehavior: behaviorConfiguration,
  },
};
const realm = await Realm.open(config);
const pauseSyncSession = () => {
  realm.syncSession?.pause();
};
const resumeSyncSession = () => {
  realm.syncSession?.resume();
};

const behaviorConfiguration: Realm.OpenRealmBehaviorConfiguration = {
  type: Realm.OpenRealmBehaviorType.OpenImmediately,
};
const config: Realm.Configuration = {
  schema: [DogSchema],
  sync: {
    user: app.currentUser!,
    partitionValue: "MyPartitionValue",
    newRealmFileBehavior: behaviorConfiguration,
    existingRealmFileBehavior: behaviorConfiguration,
  },
};
const realm = await Realm.open(config);
const pauseSyncSession = () => {
  realm.syncSession?.pause();
};
const resumeSyncSession = () => {
  realm.syncSession?.resume();
};

Cuándo pausar una sesión de sincronización

En la mayoría de las aplicaciones, no es necesario pausar y reanudar manualmente una sesión de sincronización. Sin embargo, existen algunas circunstancias en las que podría ser conveniente pausar o suspender una sesión de sincronización:

Solo desea sincronizar después de que el usuario realice una acción específica
Solo desea sincronizar durante un momento determinado del día.
No debes intentar sincronizar cuando hay una mala conectividad de red
Quiere forzar explícitamente una sesión de sincronización para conectarse

En el caso de una mala conectividad de red, intentar continuamente establecer una conexión de red puede agotar la batería del dispositivo del usuario.

El caso de forzar explícitamente la conexión de una sesión de sincronización suele estar relacionado con estar desconectado durante un tiempo. El cliente de sincronización intenta conectarse y, al fallar, entra en una fase de desconexión exponencial. Tras un tiempo prolongado desconectado, es posible que el cliente no se vuelva a conectar inmediatamente. Pausar y reanudar la sesión de sincronización fuerza explícitamente la conexión.

Cuando pause una sesión de sincronización, tenga en cuenta lo siguiente:

Si el cliente puede estar fuera de línea por un tiempo mayor al máximo permitido, no podrá reanudar la sincronización y deberá reiniciarlo.
Pausar una sesión de sincronización la pausa en ambos sentidos. Los cambios que realiza la aplicación en el dispositivo no se sincronizan con el backend, y los cambios en los datos del backend o de otros dispositivos no se sincronizan con el dispositivo. No es posible pausar solo las cargas ni las descargas.
No pause una sesión de sincronización si desea que un cliente deje de sincronizarse permanentemente con el backend. Para ello, copie el contenido del dominio sincronizado en uno no sincronizado y utilice este último en el cliente.

No pause la sincronización para detenerla por períodos indefinidos o intervalos de tiempo de meses o años. Esta función no está diseñada ni probada para estos casos de uso. Podría experimentar diversos problemas al usarla de esta manera.

Esperar a que se cargue y descargue

Para esperar asincrónicamente a que se carguen todos los cambios a Atlas desde el dominio sincronizado, llama a uploadAllLocalChanges(). Este método devuelve "true" cuando se han cargado todos los cambios.

realm.write(() => {
  realm.create(Doggie, {
    _id: new BSON.ObjectID(),
    owner_id: app.currentUser!.id,
    name: "Maui",
    age: 3,
  });
});
await realm.syncSession?.uploadAllLocalChanges();

Para esperar asincrónicamente a que todos los cambios en Atlas se descarguen del servidor de sincronización de dispositivos a su dominio sincronizado, llame a downloadAllServerChanges(). Este método devuelve "true" cuando se hayan descargado todos los cambios.

await realm.syncSession?.downloadAllServerChanges();

Puede especificar un tiempo de espera de solicitud en la configuración de la aplicación. Con un tiempo de espera especificado, puede configurar cancelWaitsOnNonFatalErrors En su BaseSyncConfiguration. Cuando true y el intervalo de tiempo de espera se alcanzan, cualquier trabajo pendiente que esté pendiente de cargas y descargas se cancela. Si esta configuración es falsa, la espera de cargas y descargas no se cancela, ya que Realm trata estos tiempos de espera como errores no fatales.

Para obtener más información, revisa Configura un tiempo de espera para la aplicación cliente y Cancela operaciones asíncronas después de un tiempo de espera.

Consulta el progreso de carga y descarga para una sesión de sincronización

Para verificar el progreso de carga y descarga de una sesión de sincronización, agregue una notificación de progreso usando el método syncSession.addProgressNotification().

El método syncSession.addProgressNotification() toma los siguientes tres parámetros:

Un parámetro direction. Ajuste en "upload" para registrar notificaciones de carga de datos. Establécelo en "download" para registrar notificaciones al descargar datos.
Un mode parámetro. Configúrelo en "reportIndefinitely" para que las notificaciones continúen hasta que se cancele el registro de la devolución de llamada mediante syncSession.removeProgressNotification(). Configúrelo en "forCurrentlyOutstandingWork" para que las notificaciones continúen hasta que solo se sincronicen los bytes transferibles actualmente.
Un parámetro de función de devolución de llamada que tiene los argumentos transferred y transferable. transferred es el número actual de bytes ya transferidos. transferable es el número total de bytes ya transferidos más el número de bytes pendientes de transferencia.

Nota

Las notificaciones de progreso de la sincronización flexible aún no son totalmente compatibles. Al usar la sincronización flexible, las descargas solo notifican las notificaciones después de integrar los cambios. La sincronización basada en particiones proporciona notificaciones continuas a medida que se descargan los cambios. Las cargas informan del progreso en ambos modos de sincronización.

Ejemplo

En el siguiente ejemplo, un desarrollador de aplicaciones registra una devolución de llamada en syncSession para escuchar eventos de carga indefinidamente. El desarrollador escribe en el dominio y luego cancela el registro de la devolución de llamada de notificación syncSession.

const behaviorConfiguration = {
  type: "openImmediately",
};
const config = {
  schema: [DogSchema],
  sync: {
    user: app.currentUser,
    partitionValue: "MyPartitionValue",
    newRealmFileBehavior: behaviorConfiguration,
    existingRealmFileBehavior: behaviorConfiguration,
  },
};
const realm = await Realm.open(config);
const handleNotifcationRemoval = (transferred, transferable) => {
  console.log(`There were ${transferable} transferable bytes total.`);
  console.log(`${transferred} bytes were transferred.`);
};
const handleNotifications = (transferred, transferable) => {
  if (transferred === transferable) {
    console.log(
      `${transferred} bytes of ${transferable} were transferred.`
    );
    // Remove progress notification.
    realm.syncSession?.removeProgressNotification(handleNotifcationRemoval);
  }
};
realm.syncSession?.addProgressNotification(
  "upload",
  "reportIndefinitely",
  handleNotifications
);
// Upload a Realm object.
const dog = realm.write(() => {
  return realm.create("Dog", {
    _id: new Realm.BSON.ObjectID(),
    MyPartitionValue: "MyPartitionValue",
    name: "Fido",
    age: 2,
  });
});

const behaviorConfiguration: Realm.OpenRealmBehaviorConfiguration = {
  type: Realm.OpenRealmBehaviorType.OpenImmediately,
};
const config: Realm.Configuration = {
  schema: [DogSchema],
  sync: {
    user: app.currentUser!,
    partitionValue: "MyPartitionValue",
    newRealmFileBehavior: behaviorConfiguration,
    existingRealmFileBehavior: behaviorConfiguration,
  },
};
const realm = await Realm.open(config);
const handleNotifcationRemoval = (
  transferred: number,
  transferable: number
) => {
  console.log(`There were ${transferable} transferable bytes total.`);
  console.log(`${transferred} bytes were transferred.`);
};
const handleNotifications = (transferred: number, transferable: number) => {
  if (transferred === transferable) {
    console.log(
      `${transferred} bytes of ${transferable} were transferred.`
    );
    // Remove progress notification.
    realm.syncSession?.removeProgressNotification(handleNotifcationRemoval);
  }
};
realm.syncSession?.addProgressNotification(
  Realm.ProgressDirection.Upload,
  Realm.ProgressMode.ReportIndefinitely,
  handleNotifications
);
// Upload a Realm object.
const dog = realm.write(() => {
  return realm.create("Dog", {
    _id: new Realm.BSON.ObjectID(),
    MyPartitionValue: "MyPartitionValue",
    name: "Fido",
    age: 2,
  });
});

Compruebe la conexión de red

Para comprobar el estado actual de la conexión al servidor, llame al método syncSession.connectionState().

El diseño de Realm, que prioriza el uso sin conexión, implica que, por lo general, no es necesario verificar el estado actual de la conexión de red. Dicho esto, el syncSession.connectionState() método está disponible si la aplicación necesita obtener el estado actual de la conexión al servidor.

const config = {
  schema: [DogSchema],
  sync: {
    user: app.currentUser,
    partitionValue: "MyPartitionValue",
  },
};
const realm = await Realm.open(config);
const connectionState = realm.syncSession?.connectionState;

const config: Realm.Configuration = {
  schema: [DogSchema],
  sync: {
    user: app.currentUser!,
    partitionValue: "MyPartitionValue",
  },
};
const realm = await Realm.open(config);
const connectionState = realm.syncSession?.connectionState;

Sesiones de sincronización multiplex

Habilitar multiplexación de sesiones Para consolidar varias sesiones de sincronización de una aplicación Realm. Utilice la multiplexación de sesiones solo si detecta errores al alcanzar el límite de descriptores de archivo y sabe que está utilizando muchas sesiones de sincronización.

Para habilitar la multiplexación de sesiones, llame a Realm.App.Sync.enableSessionMultiplexing() con su Realm.App.

Ejemplo

Realm.App.Sync.enableSessionMultiplexing(app);

Volver

Administrar suscripciones de sincronización flexible

Manejar errores de sincronización